Convert object to String using Iterator pattern

When manipulating JSOM, XML, Java beans and other objects, you may first think of the visitor pattern. But using the visitor pattern it is difficult to control callbacks from the calling code. For example, you cannot conditionally skip a branch from all callback sub-branches and leaf nodes. To solve this problem, you can use the Iterator pattern to traverse the entire object and generate a string that is easy for developers to read and debug. This iterator is quite versatile and I've used it in both tools for finding Java objects using XPath and logging exceptions in StackHunter.

API

This article mainly introduces two classes: StringGenerator and ObjectIterator.

String Generator

StringGenerator tool class converts objects into strings to make objects more readable. You can use it to implement the toString method of the class or use the string expression of the object as log debugging code:

package com.stackhunter.util.tostring.example;

import com.stackhunter.example.employee.Department;
import com.stackhunter.example.employee.Employee;
import com.stackhunter.example.employee.Manager;
import com.stackhunter.example.people.Person;

import com.stackhunter.util.tostring.StringGenerator;

public class StringGeneratorExample {

    public static void main(String[] args) {
        Department department = new Department(5775, "Sales")
        .setEmployees(
                new Employee(111, "Bill", "Gates"),
                new Employee(222, "Howard", "Schultz"),
                new Manager(333, "Jeff", "Bezos", 75000));

        System.out.println(StringGenerator.generate(department));
        System.out.println(StringGenerator.generate(new int[] { 111, 222, 333 }));
        System.out.println(StringGenerator.generate(true));
    }

}

StringGenerator.generate() formats department, array and boolean values ​​to output.

com.stackhunter.example.employee.Department@129719f4
  deptId = 5775
  employeeList = java.util.ArrayList@7037717a
    employeeList[0] = com.stackhunter.example.employee.Employee@17a323c0
      firstName = Bill
      id = 111
      lastName = Gates
    employeeList[1] = com.stackhunter.example.employee.Employee@57801e5f
      firstName = Howard
      id = 222
      lastName = Schultz
    employeeList[2] = com.stackhunter.example.employee.Manager@1c4a1bda
      budget = 75000.0
      firstName = Jeff
      id = 333
      lastName = Bezos
  name = Sales
[I@39df3255
  object[0] = 111
  object[1] = 222
  object[2] = 333
true

Object Iterator

ObjectIterator uses the iterator pattern to traverse the properties of the object and save them in the form of key-value pairs. Java beans, collections, arrays and maps in objects must be iterated. ObjectIterator also takes into account the handling of circular references between objects.

package com.stackhunter.util.tostring.example;

import com.stackhunter.example.employee.Department;
import com.stackhunter.example.employee.Employee;
import com.stackhunter.example.employee.Manager;
import com.stackhunter.util.objectiterator.ObjectIterator;

public class ObjectIteratorExample {

    public static void main(String[] args) {
        Department department = new Department(5775, "Sales")
        .setEmployees(
                new Employee(111, "Bill", "Gates"),
                new Employee(222, "Howard", "Schultz"),
                new Manager(333, "Jeff", "Bezos", 75000));

        ObjectIterator iterator = new ObjectIterator("some department", department);

        while (iterator.next()) {
            System.out.println(iterator.getName() + "=" + iterator.getValueAsString());
        }
    }

}

Generates a collection of key-value pairs by traversing the entire object. Use the getValueAsString() method instead of toString() to format the output. Use the original toString() implementation for primitive types, wrapped types, strings, dates, and enumerations. For other types, the class name and hash value are output.

ObjectIterator.getDepth() will increase the indentation and make the output more readable. Use nextParent() before calling next() to shorten the current branch and jump to the next attribute.

some department=com.stackhunter.example.employee.Department@780324ff
deptId=5775
employeeList=java.util.ArrayList@6bd15108
employeeList[0]=com.stackhunter.example.employee.Employee@22a79c31
firstName=Bill
...

Concrete implementation of Java object iterator

The first step to implement the iterator pattern is to create a general iterator interface: IObjectIterator. This interface can be used regardless of whether the traversed object is a Java bean, an array or a map.

public interface IObjectIterator {
    boolean next();
    String getName();
    Object getValue();
}

Use this interface to obtain the name and value of the current attribute in a single order.

Classes that implement IObjectIterator are used to process objects of a certain type. Most classes call getName() to return the name prefix. ArrayIterator uses the index of the element: return name + "[" + nextIndex + "]";.

Property Iterator

PropertyIterator is probably the most important iteration class. It uses Java bean introspection to read object properties and convert them into a sequence of key-value pairs.

public class PropertyIterator implements IObjectIterator {

    private final Object object;
    private final PropertyDescriptor[] properties;
    private int nextIndex = -1;
    private PropertyDescriptor currentProperty;

    public PropertyIterator(Object object) {
        this.object = object;
        try {
            BeanInfo beanInfo = Introspector.getBeanInfo(object.getClass());
            properties = beanInfo.getPropertyDescriptors();
        } catch (RuntimeException e) {
            throw e;
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage(), e);
        }
    }

    @Override
    public boolean next() {
        if (nextIndex + 1 >= properties.length) {
            return false;
        }

        nextIndex++;
        currentProperty = properties[nextIndex];
        if (currentProperty.getReadMethod() == null || "class".equals(currentProperty.getName())) {
            return next();
        }
        return true;
    }

    @Override
    public String getName() {
        if (currentProperty == null) {
            return null;
        }
        return currentProperty.getName();
    }

    @Override
    public Object getValue() {
        try {
            if (currentProperty == null) {
                return null;
            }
            return currentProperty.getReadMethod().invoke(object);
        } catch (RuntimeException e) {
            throw e;
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage(), e);
        }
    }

}

Array Iterator

ArrayIterator gets the length of the array through reflection, and then retrieves each data element. ArrayIterator does not care about the specific details of the value returned from the getValue() method. They are normally passed to PropertyIterator.

public class ArrayIterator implements IObjectIterator {

    private final String name;
    private final Object array;
    private final int length;
    private int nextIndex = -1;
    private Object currentElement;

    public ArrayIterator(String name, Object array) {
        this.name = name;
        this.array = array;
        this.length = Array.getLength(array);
    }

    @Override
    public boolean next() {
        if (nextIndex + 1 >= length) {
            return false;
        }

        nextIndex++;
        currentElement = Array.get(array, nextIndex);
        return true;
    }

    @Override
    public String getName() {
        return name + "[" + nextIndex + "]";
    }

    @Override
    public Object getValue() {
        return currentElement;
    }

}

集合迭代器

CollectionIterator与ArrayIterator非常相似。使用java.lang.Iterable调用它的Iterable.iterator()方法初始化内部迭代器。

Map迭代器

MapIterator遍历java.util.Map的entry。它并不深入到每个entry的键值对，这个工作由MapEntryIterator类完成。

public class MapIterator implements IObjectIterator {

    private final String name;
    private Iterator<?> entryIterator;
    private Map.Entry<?, ?> currentEntry;
    private int nextIndex = -1;

    public MapIterator(String name, Map<?, ?> map) {
        this.name = name;
        this.entryIterator = map.entrySet().iterator();
    }

    @Override
    public boolean next() {
        if (entryIterator.hasNext()) {
            nextIndex++;
            currentEntry = (Entry<?, ?>) entryIterator.next();
            return true;
        }
        return false;
    }

    ...

}

Map Entry迭代器

MapEntryIterator处理java.util.Map的单个entry。它只返回两个值：entry的键和值。与ArrayIterator及其他的类似，如果是复杂类型的话，它的结果可能最终传递给PropertyIterator，作为Java bean处理。

根迭代器

RootIterator返回单个元素——初始节点。可以把它想成XML文件的根节点。目的是发起整个遍历过程。

整合

ObjectIterator类作为门面角色（Facade），包装了所有的遍历逻辑。它根据最后一次getValue()的返回值类型决定哪个IObjectIterator的子类需要实例化。当子迭代器在内部创建时它在栈中保存当前迭代器的状态。它也暴露了getChild()和getDepth()方法为调用者展示当前进度。

private IObjectIterator iteratorFor(Object object) {
    try {
        if (object == null) {
            return null;
        }

        if (object.getClass().isArray()) {
            return new ArrayIterator(name, object);
        }

        if (object instanceof Iterable) {
            return new CollectionIterator(name, (Iterable<?>) object);
        }

        if (object instanceof Map) {
            return new MapIterator(name, (Map<?, ?>) object);
        }

        if (object instanceof Map.Entry) {
            return new MapEntryIterator(name, (Map.Entry<?, ?>) object);
        }

        if (isSingleValued(object)) {
            return null;
        }

        return new PropertyIterator(object);
    } catch (RuntimeException e) {
        throw e;
    } catch (Exception e) {
        throw new RuntimeException(e.getMessage(), e);
    }

}

字符串生成器的实现

已经看到如何遍历对象中的所有属性。最后的工作就是让输出更加美观，以及增加一些限制条件（比如不能创建一个GB级大小的字符串）。

public static String generate(Object object) {
    String s = "";

    ObjectIterator iterator = new ObjectIterator("object", object);

    ...

    while (iterator.next()) {
        if (s.length() >= MAX_STRING_LENGTH) {
            return s;
        }

        if (iterator.getChild() >= MAX_CHILDREN) {
            iterator.nextParent();
            continue;
        }

        String valueAsString = iterator.getValueAsString();

        s += System.lineSeparator();
        s += indent(iterator.getDepth()) + truncateString(iterator.getName());
        if (valueAsString == null) {
            s += " = null";
        } else {
            s += " = " + truncateString(valueAsString);
        }
    }

    return s;
}

代码第21行完成了格式化，增加了缩进和层次结构使显示更美观。

同时增加了一些限制条件：

第9行——限制字符串长度在16k内。

第13行——限制任何父节点下子节点数量小于64.

第21&25行——限制键和值长度在64个字符。

总结

本文介绍了如何使用迭代器模式遍历包含各种复杂属性的对象。关键是将每种类型的迭代委派给各自的类实现。可以在你自己的软件中使用这两个工具。