Javaオブジェクトのプロパティのダンプ
オブジェクトのプロパティを再帰的にダンプ/印刷するライブラリはありますか？ Firebugの console.dir（） 関数に似たものを探しています。
Commons-lang ReflectionToStringBuilder を知っていますが、オブジェクトに再帰しません。つまり、次を実行した場合：
public class ToString {
public static void main(String [] args) {
System.out.println(ReflectionToStringBuilder.toString(new Outer(), ToStringStyle.MULTI_LINE_STYLE));
}
private static class Outer {
private int intValue = 5;
private Inner innerValue = new Inner();
}
private static class Inner {
private String stringValue = "foo";
}
}
私は受け取ります：
ToString $ Outer @ 1b67f74 [intValue = 5
innerValue = ToString $ Inner @ 530daa]
私の例では、InnerのtoString（）メソッドをオーバーライドできたが、実際には、変更できない外部オブジェクトを扱っていることに気付きました。
XStream を試すことができます。
XStream xstream = new XStream(new Sun14ReflectionProvider(
new FieldDictionary(new ImmutableFieldKeySorter())),
new DomDriver("utf-8"));
System.out.println(xstream.toXML(new Outer()));
プリントアウト：
<foo.ToString_-Outer>
<intValue>5</intValue>
<innerValue>
<stringValue>foo</stringValue>
</innerValue>
</foo.ToString_-Outer>
[〜＃〜] json [〜＃〜] で出力することもできます
そして、循環参照に注意してください;）
最初に提案したようにXStreamを使用しようとしましたが、ダンプしたいオブジェクトグラフにはXStreamマーシャラー自体への参照が含まれていたことがわかりました。それはあまり親切にはなりませんでした（なぜそれを無視するのではなく例外をスローする必要があるか素敵な警告を記録しますが、わかりません。）
次に、上記のuser519500のコードを試しましたが、いくつかの調整が必要であることがわかりました。これは、次の追加機能を提供するプロジェクトにロールインできるクラスです。
- 最大再帰深度を制御できます
- 配列要素の出力を制限できます
- クラス、フィールド、またはクラスとフィールドの組み合わせのリストは無視できます。クラス名の組み合わせ、コロンで区切られたクラス名とフィールド名のペア、またはコロンのプレフィックスを持つフィールド名を配列に渡すだけです。つまり、
[<classname>][:<fieldname>] - 同じオブジェクトを2回出力しません（出力は、オブジェクトが以前にアクセスされたときを示し、相関のハッシュコードを提供します）-これにより、問題を引き起こす循環参照が回避されます
以下の2つの方法のいずれかを使用して、これを呼び出すことができます。
String dump = Dumper.dump(myObject);
String dump = Dumper.dump(myObject, maxDepth, maxArrayElements, ignoreList);
前述のように、これではスタックオーバーフローに注意する必要があるため、最大再帰深度機能を使用してリスクを最小限に抑えます。
うまくいけば、誰かがこれを役に立つと思うでしょう！
package com.mycompany.myproject;
import Java.lang.reflect.Array;
import Java.lang.reflect.Field;
import Java.util.HashMap;
public class Dumper {
private static Dumper instance = new Dumper();
protected static Dumper getInstance() {
return instance;
}
class DumpContext {
int maxDepth = 0;
int maxArrayElements = 0;
int callCount = 0;
HashMap<String, String> ignoreList = new HashMap<String, String>();
HashMap<Object, Integer> visited = new HashMap<Object, Integer>();
}
public static String dump(Object o) {
return dump(o, 0, 0, null);
}
public static String dump(Object o, int maxDepth, int maxArrayElements, String[] ignoreList) {
DumpContext ctx = Dumper.getInstance().new DumpContext();
ctx.maxDepth = maxDepth;
ctx.maxArrayElements = maxArrayElements;
if (ignoreList != null) {
for (int i = 0; i < Array.getLength(ignoreList); i++) {
int colonIdx = ignoreList[i].indexOf(':');
if (colonIdx == -1)
ignoreList[i] = ignoreList[i] + ":";
ctx.ignoreList.put(ignoreList[i], ignoreList[i]);
}
}
return dump(o, ctx);
}
protected static String dump(Object o, DumpContext ctx) {
if (o == null) {
return "<null>";
}
ctx.callCount++;
StringBuffer tabs = new StringBuffer();
for (int k = 0; k < ctx.callCount; k++) {
tabs.append("\t");
}
StringBuffer buffer = new StringBuffer();
Class oClass = o.getClass();
String oSimpleName = getSimpleNameWithoutArrayQualifier(oClass);
if (ctx.ignoreList.get(oSimpleName + ":") != null)
return "<Ignored>";
if (oClass.isArray()) {
buffer.append("\n");
buffer.append(tabs.toString().substring(1));
buffer.append("[\n");
int rowCount = ctx.maxArrayElements == 0 ? Array.getLength(o) : Math.min(ctx.maxArrayElements, Array.getLength(o));
for (int i = 0; i < rowCount; i++) {
buffer.append(tabs.toString());
try {
Object value = Array.get(o, i);
buffer.append(dumpValue(value, ctx));
} catch (Exception e) {
buffer.append(e.getMessage());
}
if (i < Array.getLength(o) - 1)
buffer.append(",");
buffer.append("\n");
}
if (rowCount < Array.getLength(o)) {
buffer.append(tabs.toString());
buffer.append(Array.getLength(o) - rowCount + " more array elements...");
buffer.append("\n");
}
buffer.append(tabs.toString().substring(1));
buffer.append("]");
} else {
buffer.append("\n");
buffer.append(tabs.toString().substring(1));
buffer.append("{\n");
buffer.append(tabs.toString());
buffer.append("hashCode: " + o.hashCode());
buffer.append("\n");
while (oClass != null && oClass != Object.class) {
Field[] fields = oClass.getDeclaredFields();
if (ctx.ignoreList.get(oClass.getSimpleName()) == null) {
if (oClass != o.getClass()) {
buffer.append(tabs.toString().substring(1));
buffer.append(" Inherited from superclass " + oSimpleName + ":\n");
}
for (int i = 0; i < fields.length; i++) {
String fSimpleName = getSimpleNameWithoutArrayQualifier(fields[i].getType());
String fName = fields[i].getName();
fields[i].setAccessible(true);
buffer.append(tabs.toString());
buffer.append(fName + "(" + fSimpleName + ")");
buffer.append("=");
if (ctx.ignoreList.get(":" + fName) == null &&
ctx.ignoreList.get(fSimpleName + ":" + fName) == null &&
ctx.ignoreList.get(fSimpleName + ":") == null) {
try {
Object value = fields[i].get(o);
buffer.append(dumpValue(value, ctx));
} catch (Exception e) {
buffer.append(e.getMessage());
}
buffer.append("\n");
}
else {
buffer.append("<Ignored>");
buffer.append("\n");
}
}
oClass = oClass.getSuperclass();
oSimpleName = oClass.getSimpleName();
}
else {
oClass = null;
oSimpleName = "";
}
}
buffer.append(tabs.toString().substring(1));
buffer.append("}");
}
ctx.callCount--;
return buffer.toString();
}
protected static String dumpValue(Object value, DumpContext ctx) {
if (value == null) {
return "<null>";
}
if (value.getClass().isPrimitive() ||
value.getClass() == Java.lang.Short.class ||
value.getClass() == Java.lang.Long.class ||
value.getClass() == Java.lang.String.class ||
value.getClass() == Java.lang.Integer.class ||
value.getClass() == Java.lang.Float.class ||
value.getClass() == Java.lang.Byte.class ||
value.getClass() == Java.lang.Character.class ||
value.getClass() == Java.lang.Double.class ||
value.getClass() == Java.lang.Boolean.class ||
value.getClass() == Java.util.Date.class ||
value.getClass().isEnum()) {
return value.toString();
} else {
Integer visitedIndex = ctx.visited.get(value);
if (visitedIndex == null) {
ctx.visited.put(value, ctx.callCount);
if (ctx.maxDepth == 0 || ctx.callCount < ctx.maxDepth) {
return dump(value, ctx);
}
else {
return "<Reached max recursion depth>";
}
}
else {
return "<Previously visited - see hashCode " + value.hashCode() + ">";
}
}
}
private static String getSimpleNameWithoutArrayQualifier(Class clazz) {
String simpleName = clazz.getSimpleName();
int indexOfBracket = simpleName.indexOf('[');
if (indexOfBracket != -1)
return simpleName.substring(0, indexOfBracket);
return simpleName;
}
}
ReflectionToStringBuilderをカスタムToStringStyleで使用できます。次に例を示します。
class MyStyle extends ToStringStyle {
private final static ToStringStyle instance = new MyStyle();
public MyStyle() {
setArrayContentDetail(true);
setUseShortClassName(true);
setUseClassName(false);
setUseIdentityHashCode(false);
setFieldSeparator(", " + SystemUtils.LINE_SEPARATOR + " ");
}
public static ToStringStyle getInstance() {
return instance;
};
@Override
public void appendDetail(StringBuffer buffer, String fieldName, Object value) {
if (!value.getClass().getName().startsWith("Java")) {
buffer.append(ReflectionToStringBuilder.toString(value, instance));
} else {
super.appendDetail(buffer, fieldName, value);
}
}
@Override
public void appendDetail(StringBuffer buffer, String fieldName, Collection value) {
appendDetail(buffer, fieldName, value.toArray());
}
}
そして、次のように呼び出します：
ReflectionToStringBuilder.toString(value, MyStyle.getInstance());
ただし、循環参照に注意してください！
Json-lib（ http://json-lib.sourceforge.net ）を使用することもできます。
JSONObject.fromObject(value);
これにより、オブジェクトのすべてのフィールド（オブジェクトの配列を含む）が出力されます。
このスレッド からのBen Williams投稿の修正バージョン
注：このメソッドは再帰を使用するため、非常に深いオブジェクトグラフがある場合は、スタックオーバーフローが発生する可能性があります（しゃれを意図しない;）IF VM parameter -Xss10mを使用する必要があります。 Eclipseを使用してrun> runconfiguration> augments（tab）VM Augment boxに配置し、適用を押します
import Java.lang.reflect.Array;
import Java.lang.reflect.Field;
public static String dump(Object o) {
StringBuffer buffer = new StringBuffer();
Class oClass = o.getClass();
if (oClass.isArray()) {
buffer.append("Array: ");
buffer.append("[");
for (int i = 0; i < Array.getLength(o); i++) {
Object value = Array.get(o, i);
if (value.getClass().isPrimitive() ||
value.getClass() == Java.lang.Long.class ||
value.getClass() == Java.lang.Integer.class ||
value.getClass() == Java.lang.Boolean.class ||
value.getClass() == Java.lang.String.class ||
value.getClass() == Java.lang.Double.class ||
value.getClass() == Java.lang.Short.class ||
value.getClass() == Java.lang.Byte.class
) {
buffer.append(value);
if(i != (Array.getLength(o)-1)) buffer.append(",");
} else {
buffer.append(dump(value));
}
}
buffer.append("]\n");
} else {
buffer.append("Class: " + oClass.getName());
buffer.append("{\n");
while (oClass != null) {
Field[] fields = oClass.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
fields[i].setAccessible(true);
buffer.append(fields[i].getName());
buffer.append("=");
try {
Object value = fields[i].get(o);
if (value != null) {
if (value.getClass().isPrimitive() ||
value.getClass() == Java.lang.Long.class ||
value.getClass() == Java.lang.String.class ||
value.getClass() == Java.lang.Integer.class ||
value.getClass() == Java.lang.Boolean.class ||
value.getClass() == Java.lang.Double.class ||
value.getClass() == Java.lang.Short.class ||
value.getClass() == Java.lang.Byte.class
) {
buffer.append(value);
} else {
buffer.append(dump(value));
}
}
} catch (IllegalAccessException e) {
buffer.append(e.getMessage());
}
buffer.append("\n");
}
oClass = oClass.getSuperclass();
}
buffer.append("}\n");
}
return buffer.toString();
}
この問題に対するエレガントな解決策が必要でした：
- 外部ライブラリを使用しません
- Reflection を使用して、スーパークラスフィールドを含むフィールドにアクセスします
- 再帰を使用して、呼び出しごとに1つのスタックフレームのみでオブジェクトグラフをトラバースします。
- IdentityHashMap を使用して、後方参照を処理し、無限再帰を回避します
- プリミティブ、オートボクシング、CharSequence、列挙、およびヌルを適切に処理します
- 静的フィールドを解析するかどうかを選択できます
- 書式設定に従って変更するのに十分なほど簡単です
次のユーティリティクラスを作成しました。
import Java.lang.reflect.Array;
import Java.lang.reflect.Field;
import Java.lang.reflect.Modifier;
import Java.util.IdentityHashMap;
import Java.util.Map.Entry;
import Java.util.TreeMap;
/**
* Utility class to dump {@code Object}s to string using reflection and recursion.
*/
public class StringDump {
/**
* Uses reflection and recursion to dump the contents of the given object using a custom, JSON-like notation (but not JSON). Does not format static fields.<p>
* @see #dump(Object, boolean, IdentityHashMap, int)
* @param object the {@code Object} to dump using reflection and recursion
* @return a custom-formatted string representing the internal values of the parsed object
*/
public static String dump(Object object) {
return dump(object, false, new IdentityHashMap<Object, Object>(), 0);
}
/**
* Uses reflection and recursion to dump the contents of the given object using a custom, JSON-like notation (but not JSON).<p>
* Parses all fields of the runtime class including super class fields, which are successively prefixed with "{@code super.}" at each level.<p>
* {@code Number}s, {@code enum}s, and {@code null} references are formatted using the standard {@link String#valueOf()} method.
* {@code CharSequences}s are wrapped with quotes.<p>
* The recursive call invokes only one method on each recursive call, so limit of the object-graph depth is one-to-one with the stack overflow limit.<p>
* Backwards references are tracked using a "visitor map" which is an instance of {@link IdentityHashMap}.
* When an existing object reference is encountered the {@code "sysId"} is printed and the recursion ends.<p>
*
* @param object the {@code Object} to dump using reflection and recursion
* @param isIncludingStatics {@code true} if {@code static} fields should be dumped, {@code false} to skip them
* @return a custom-formatted string representing the internal values of the parsed object
*/
public static String dump(Object object, boolean isIncludingStatics) {
return dump(object, isIncludingStatics, new IdentityHashMap<Object, Object>(), 0);
}
private static String dump(Object object, boolean isIncludingStatics, IdentityHashMap<Object, Object> visitorMap, int tabCount) {
if (object == null ||
object instanceof Number || object instanceof Character || object instanceof Boolean ||
object.getClass().isPrimitive() || object.getClass().isEnum()) {
return String.valueOf(object);
}
StringBuilder builder = new StringBuilder();
int sysId = System.identityHashCode(object);
if (object instanceof CharSequence) {
builder.append("\"").append(object).append("\"");
}
else if (visitorMap.containsKey(object)) {
builder.append("(sysId#").append(sysId).append(")");
}
else {
visitorMap.put(object, object);
StringBuilder tabs = new StringBuilder();
for (int t = 0; t < tabCount; t++) {
tabs.append("\t");
}
if (object.getClass().isArray()) {
builder.append("[").append(object.getClass().getName()).append(":sysId#").append(sysId);
int length = Array.getLength(object);
for (int i = 0; i < length; i++) {
Object arrayObject = Array.get(object, i);
String dump = dump(arrayObject, isIncludingStatics, visitorMap, tabCount + 1);
builder.append("\n\t").append(tabs).append("\"").append(i).append("\":").append(dump);
}
builder.append(length == 0 ? "" : "\n").append(length == 0 ? "" : tabs).append("]");
}
else {
// enumerate the desired fields of the object before accessing
TreeMap<String, Field> fieldMap = new TreeMap<String, Field>(); // can modify this to change or omit the sort order
StringBuilder superPrefix = new StringBuilder();
for (Class<?> clazz = object.getClass(); clazz != null && !clazz.equals(Object.class); clazz = clazz.getSuperclass()) {
Field[] fields = clazz.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
Field field = fields[i];
if (isIncludingStatics || !Modifier.isStatic(field.getModifiers())) {
fieldMap.put(superPrefix + field.getName(), field);
}
}
superPrefix.append("super.");
}
builder.append("{").append(object.getClass().getName()).append(":sysId#").append(sysId);
for (Entry<String, Field> entry : fieldMap.entrySet()) {
String name = entry.getKey();
Field field = entry.getValue();
String dump;
try {
boolean wasAccessible = field.isAccessible();
field.setAccessible(true);
Object fieldObject = field.get(object);
field.setAccessible(wasAccessible); // the accessibility flag should be restored to its prior ClassLoader state
dump = dump(fieldObject, isIncludingStatics, visitorMap, tabCount + 1);
}
catch (Throwable e) {
dump = "!" + e.getClass().getName() + ":" + e.getMessage();
}
builder.append("\n\t").append(tabs).append("\"").append(name).append("\":").append(dump);
}
builder.append(fieldMap.isEmpty() ? "" : "\n").append(fieldMap.isEmpty() ? "" : tabs).append("}");
}
}
return builder.toString();
}
}
多くのクラスでテストしましたが、私にとっては非常に効率的です。たとえば、メインスレッドのダンプに使用してみてください。
public static void main(String[] args) throws Exception {
System.out.println(dump(Thread.currentThread()));
}
編集
この投稿を書いてから、このアルゴリズムの反復バージョンを作成する理由がありました。再帰バージョンは、スタックフレームの合計によって深さが制限されていますが、非常に大きなオブジェクトグラフをダンプする理由があるかもしれません。私の状況を処理するために、ランタイムスタックの代わりにスタックデータ構造を使用するようにアルゴリズムを修正しました。このバージョンは時間効率が良く、スタックフレームの深さではなくヒープサイズによって制限されます。
ここでの反復バージョン をダウンロードして使用できます。
XStream 、 Digester 、または [〜＃〜] jaxb [〜＃〜] のようなXMLバインディングフレームワークを使用できます。
RecursiveToStringStyleを使用する必要があります。
System.out.println(ReflectionToStringBuilder.toString(new Outer(), new RecursiveToStringStyle()));
Gson を使用して、オブジェクトをjson形式で表すことができます。
new GsonBuilder().setPrettyPrinting().create().toJson(yourObject);
[〜＃〜] gson [〜＃〜] Lib fo Javaを使用することをお勧めします。
mavenを使用する場合は、 this を使用できます。
または、Jarファイルを here からダウンロードできます。
ここでそれを使用する方法の例：
Gson gson = new GsonBuilder().setPrettyPrinting().create();
String json = gson.toJson(obj);
System.out.println(json);
JSONObject.fromObject(value)
String以外のキーを持つMapオブジェクトでは機能しません。たぶん、JsonConfigがこれを処理できます。