调试工具类

import java.io.*;
import java.util.*;
import java.text.*;
import java.lang.reflect.*;

/**
* 调试工具类。该类提供两个主要的静态方法：
* <OL><LI>myAssert(boolean 条件);断言，用来确保本应成立的条件确实成立，防止
* 错误扩散。
* <LI>dump(任何数据类型,递归深度);输出一个变量的内容，后一个参数可省，
* 缺省值为3。该方法可以输出任何数据类型的变量的内容，包括基本数据类型、数
* 组和对象。对一些常用对象，如Vector等，有专门的输出格式。其他对象将输出其
* 成员变量，包括私有变量和静态变量。输出过程会一直递归，递归层次由deep参数
* 来控制，如果递归层次超过限制值，则直接输出toString()的内容，如果递归出现
* 循环，则在发现重复引用处停止递归。输出信息除对象的内容外还包括输出时间、
* 调用dump函数的代码所在源文件，行号，若是对象还包括该对象的地址(注：虚拟
* 机内部编址，非物理地址，可用来判断两个变量是否是同一个对象的引用)。</OL>
* 该类未引用其他类，可单独编译。该类只供调试使用，未做性能优化。
* @author sunlen
* @version 1.0
*/
public class Debug {

/**
* 构造方法私有，禁止实例化。
*/
private Debug() {}

/**
* 断言，condition条件一定成立，否则断言失败，断言失败时抛出异常，断言使用在
* 判断在任何情况下都不应该出现的错误，如果断言失败表示程序有BUG，在系统发布
* 前必须保证所有断言都永远成立。不应用断言来做为程序运行期间出错处理的手段。
* @param condition 断言条件。
* @param message 断言失败时输出的消息。
*/
public static final void myAssert(boolean condition) {
if(!condition) throw new AssertFailed();
}

//---------------dump方法，用法：Debug.dump(<任意数据类型>);-------------------

/** dump分层结构时每级缩进固定为4个空格。*/
private static String indentString = " ";

/** 当前系统行分隔符。*/
private static final String lineSeparator =
System.getProperty("line.separator");

/**
* dump()方法输出数据的目的流，缺省指向标准错误输出设备上。
* 可以通过setDumpStream(OutputStream)方法修改,也可以直接对该对象赋值。
*/
public static PrintWriter out = new PrintWriter(System.out);

/**
* 设置dump信息的输出目的流，此后调用dump都将输出到该流中。
* @param os 输出流。
*/
public static void setDumpStream(OutputStream os) {
out = new PrintWriter(os);
}

/**
* 设置dump信息的输出目的流，此后调用dump都将输出到该流中。
* @param w 一个Writer对象。
*/
public static void setDumpStream(Writer w) {
out = new PrintWriter(w);
}

/**
* 设置递归缩进时填补的字符串。缺省为4个空格。
* @param indent 缩进时填补的字符串。
*/
public static void setDumpIndent(String indent) {
indentString = indent;
}

/**
* 获取递归缩进时填补的字符串。
* @return 缩进时填补的字符串。
*/
public static String getDumpIndent() {
return indentString;
}

/**
* 输出空行。
*/
public static final void dump() {
out.println(dumpHead());
out.flush();
}

/**
* 输出整数。
* @param i 要输出的整数。
*/
public static final void dump(int i) {
out.println(dumpHead() + i);
out.flush();
}

/**
* 输出长整数。
* @param l 要输出的长整数。
*/
public static final void dump(long l) {
out.println(dumpHead() + l);
out.flush();
}

/**
* 输出浮点数。
* @param f 要输出的浮点数。
*/
public static final void dump(float f) {
out.println(dumpHead() + f);
out.flush();
}

/**
* 输出双精度浮点数。
* @param d 要输出的双精度浮点数。
*/
public static final void dump(double d) {
out.println(dumpHead() + d);
out.flush();
}

/**
* 输出布尔值。
* @param d 要输出的布尔值。
*/
public static final void dump(boolean b) {
out.println(dumpHead() + b);
out.flush();
}

/**
* 输出一个字符ch。
* @param ch 要输出的字符。
*/
public static final void dump(char ch) {
out.println(dumpHead() + ch);
out.flush();
}

/**
* 输出字节数组中的一部分数据。
* @param data 待输出数据所在字节数组。
* @param offset 待输出数据开始位置。
* @param length 待输出数据长度。
*/
public static final void dump(byte[] data,int offset,int length) {
dump(dumpHead(),data,offset,length);
}

/**
* 输出字节数组完整内容。
* @param data 待输出字节数组。
*/
public static final void dump(byte[] data){
dump(dumpHead(),data);
}

/**
* 输出一个对象（可以是任何对象、对象数组）
* @param obj 要输出的对象。
*/
public static final void dump(Object obj) {
dump(dumpHead(),3,new Vector(),obj);
}

/**
* 输出一个对象（可以是任何对象、对象数组），带前缀
* @param obj 要输出的对象。
* @param prefix 输出信息的前缀。
*/
public static final void dump(Object obj,String prefix) {
dump(prefix + dumpHead(),3,new Vector(),obj);
}

/**
* 输出一个对象（可以是任何对象、对象数组）
* @param obj 要输出的对象。
* @param depth 递归深度。
*/
public static final void dump(Object obj,int depth) {
dump(dumpHead(),depth,new Vector(),obj);
}

//------------------------ 以下是私有方法，不对外开放 -----------------------

/**
* 输出向量内容。
* @param prefix 输出前缀。
* @param depth 最大dump深度。
* @param v 输出的向量。
*/
private static final void dump(String prefix,int depth,Vector checkCircuit,Vector v){
if (v==null) {
dump(prefix,"null");
return;
}
dumpBegin(prefix,checkCircuit,v);
for (int i=0;i<v.size();i++) {
Object item = v.elementAt(i);
StringBuffer itemPrefix = new StringBuffer();
itemPrefix.append(indent(prefix));
itemPrefix.append('[');
itemPrefix.append(i);
itemPrefix.append("] ");
itemPrefix.append(formatClassName(item.getClass(),item));
itemPrefix.append(" @");
itemPrefix.append(System.identityHashCode(item));
dump(itemPrefix.toString(),depth,checkCircuit,item);
}
dumpEnd(prefix,checkCircuit,v);
}

/**
* 输出Servlet的request请求中的参数。
* @param prefix 输出前缀。
* @param request 要输出的请求。
*/
private static final void dumpServletRequest(String prefix,Object request) {
try {
if (request == null) {
dump(prefix,"null");
return;
}
dumpBegin(prefix,new Vector(),request);
Class c = request.getClass();
Method m1 = null;
m1 = c.getMethod("getParameterNames",new Class[]{});

for (Enumeration e = (Enumeration) m1.invoke(request,new Object[]{});
e.hasMoreElements();) {
String name = e.nextElement().toString();
Method m2 = c.getMethod("getParameterValues",new Class[]{String.class});
String[] values = (String[]) m2.invoke(request,new Object[]{name});
StringBuffer sb = new StringBuffer();
for (int i=0; i<values.length; i++) {
sb.append(values[i]);
if (i!=values.length -1) {
sb.append(" ; ");
}
}
dump(indent(prefix),name + " = " + sb);
}
dumpEnd(prefix,new Vector(),request);
} catch (Exception ex) {
ex.printStackTrace(out);
}
}

/**
* 输出符合Enumeration接口的对象的内容
* @param prefix 输出前缀。
* @param depth 最大dump深度。
* @param e 输出的枚举对象。
*/
private static final void dump(String prefix,int depth,Vector checkCircuit,Enumeration e){
if (e==null) {
dump(prefix,"null");
return;
}
dumpBegin(prefix,checkCircuit,e);
int i=0;
while (e.hasMoreElements()) {
dump(indent(prefix) + '[' + (i++) + "] ",depth,checkCircuit,e.nextElement());
}
dumpEnd(prefix,checkCircuit,e);
}

/**
* 输出异常信息。
* @param prefix 输出前缀。
* @param t 待输出的异常。
*/
private static final void dump (String prefix,Throwable t) {
if (t==null) {
dump(prefix,"null");
return;
}
dumpBegin(prefix,new Vector(),t);
t.printStackTrace(out);
dumpEnd(prefix,new Vector(),t);
}

/**
* 输出字节数组片段。
* @param prefix 输出前缀。
* @param data 输出的字节数组。
* @param offset 输出开始的偏移地址。
* @param length 长度。
*/
private static final void dump(String prefix,byte[]data,int offset,int length) {
if (data ==null) {
dump(prefix,"null");
return;
}
if ( offset<0||data.length<offset+length) {
dump(prefix,"IndexOutOfBounds:data.length=" + data.length + " offset=" +
offset + " length=" + length);
return;
}
dumpBegin(prefix,new Vector(),data);
int end = offset + length;
dump(indent(prefix),"[HEX] 0 1 2 3 4 5 6 7 8 9 a b c d e f | 0123456789abcdef");
dump(indent(prefix),"------------------------------------------------------------------------");
for (int i=offset; i<end; i+=16) {
byte[] row = new byte[] { 0x30,0x30,0x30,0x30,0x3A,0x20,
0x30,0x30,0x20,0x30,0x30,0x20,0x30,0x30,0x20,0x30,0x30,0x20,
0x30,0x30,0x20,0x30,0x30,0x20,0x30,0x30,0x20,0x30,0x30,0x20,
0x30,0x30,0x20,0x30,0x30,0x20,0x30,0x30,0x20,0x30,0x30,0x20,
0x30,0x30,0x20,0x30,0x30,0x20,0x30,0x30,0x20,0x30,0x30,0x20,
0x7C,0x20,0x2E,0x2E,0x2E,0x2E,0x2E,0x2E,0x2E,0x2E,0x2E,0x2E,
0x2E,0x2E,0x2E,0x2E,0x2E,0x2E
};
setHex(row,3,i);
for (int j=i; j<i+16; j++) {
if (j<end) {
int b = data[j];
if (b<0) b += 256;
setHex(row,7+(j-i)*3,b);
if (b>=32 && b<127) {
row[56+j-i]=(byte)b;
}
}
else {
row[6+(j-i)*3]=(byte)' ';
row[7+(j-i)*3]=(byte)' ';
row[56+(j-i)] =(byte)' ';
}
}
dump(indent(prefix),new String(row));
}
dumpEnd(prefix,new Vector(),data);
}

/**
* 输出字节数组完整内容。
* @param prefix 输出前缀
* @param b 输出的字节数组。
*/
private static final void dump(String prefix, byte[] b) {
dump(prefix, b, 0, b.length>512?512:b.length);
}

/**
* 输出哈希表内容。
* @param prefix 输出前缀。
* @param depth 最大dump深度。
* @param map 输出的Map对象。
*/
private static final void dump(String prefix,int depth,Vector checkCircuit,Map map){
if (map==null) {
dump(prefix,"null");
}
dumpBegin(prefix,checkCircuit,map);
for (Iterator i = map.keySet().iterator();i.hasNext();){
Object key = i.next();
Object value = map.get(key);
if (value instanceof String) {
dump(indent(prefix),key.toString() + " = " + value);
} else {
dump(indent(prefix) + key.toString() + " = ",depth,checkCircuit,map.get(key));
}
}
dumpEnd(prefix,checkCircuit,map);
}

/**
* 输出字符串。
* @param prefix 输出前缀。
* @param str 输出的字符串。
*/
private static final void dump(String prefix,String str) {
out.println(prefix+str);
out.flush();
}

/**
* 输出对象数组内容。
* @param prefix 输出前缀。
* @param depth 最大dump深度。
* @param objs 输出的对象数组。
*/
private static final void dump(String prefix,int depth,Vector checkCircuit,Object[] objs) {
if (objs==null) {
dump(prefix,"null");
return;
}
dumpBegin(prefix,checkCircuit,objs);
for (int i=0;i<objs.length;i++) {
dump(indent(prefix) + '[' + i + "] ",depth,checkCircuit,objs[i]);
}
dumpEnd(prefix,checkCircuit,objs);
}

/**
* 对一般对象的dump行为是把传入对象的成员变量(包括私有)全部显示出来。
* @param prefix 输出前缀。
* @param depth 最大dump深度。
* @param checkCircuit 保存递归层次中经过的所有对象的地址，防止循环递归。
* @param obj需要dump的对象。
*/
private static void dump(String prefix,int depth,Vector checkCircuit,Object obj) {
if (obj==null) {
dump(prefix,"null");
return;
}
try {
//对于这些常用数据类型，有他们自己的dump方法。
if ((obj instanceof String) || (obj instanceof Number) ||
(obj instanceof Character) || (obj instanceof Boolean)) {
dump(prefix,obj.toString());
return;
} else if(checkCircuit.contains(new Integer(System.identityHashCode(obj)))) {
StringBuffer sb = new StringBuffer();
sb.append(formatClassName(obj.getClass(),obj));
sb.append(" @");
sb.append(System.identityHashCode(obj));
sb.append(' ');
dump(prefix," {Circle recursion!}");
return;
} else if(getDepth(prefix)>depth) {//递归层数太多
String str = formatClassName(obj.getClass(),obj) +
" @" + System.identityHashCode(obj);
if (prefix.trim().endsWith(str.trim())) {
str = "";
}
String toStr;
try {
toStr = obj.toString();
if (toStr.indexOf((int)'@')>0) {
toStr = " {Stack overflow!}";
}
} catch (StackOverflowError t) {
toStr = " {Stack overflow!}";
}
dump(prefix,str + toStr);
return;
} else if (obj instanceof Vector) {
dump(prefix,depth,checkCircuit,(Vector)obj);
return;
} else if (obj instanceof Map) {
dump(prefix,depth,checkCircuit,(Map)obj);
return;
} else if (obj instanceof Enumeration) {
dump(prefix,depth,checkCircuit,(Enumeration)obj);
return;
} else if (obj instanceof Object[]) {
dump(prefix,depth,checkCircuit,(Object[]) obj);
return;
} else if (obj instanceof Throwable) {
dump(prefix,(Throwable) obj);
return;
} else if (obj instanceof byte[]) {
dump(prefix,(byte[]) obj);
return;
} else if (obj.getClass().isArray()) { //基本数据类型的数组
int len = Array.getLength(obj);
dumpBegin(prefix,checkCircuit,obj);
StringBuffer content = new StringBuffer();
for (int i=0;i<len;i++) {
content.append(fixLength(Array.get(obj,i).toString(),4));
if (i%8==7 && i<len-1) {
content.append(lineSeparator + indent(prefix));
}
}
dump(indent(prefix),content.toString());
dumpEnd(prefix,checkCircuit,obj);
return;
} else if (Class.forName("javax.servlet.ServletRequest").isInstance(obj)) {
dumpServletRequest(prefix,obj);
return;
}
} catch (ClassNotFoundException ex) {
//ex.printStackTrace(out);
}

//其他对象
dumpBegin(prefix,checkCircuit,obj);
Class c = obj.getClass();
Field[] f;
while (c!=null) {
try {
f = c.getDeclaredFields();
} catch (SecurityException ex2) { //如果没有执行getFields()的权限
dump(indent(prefix),"Can't dump object member for security reason.");
return;
}
//输出成员变量
for (int i=0;i<f.length;i++) {
String m = Modifier.toString(f[i].getModifiers()); //修饰符
if (m.indexOf("static")>0)
continue;
String n = f[i].getName(); //变量名
Object v = "[unkonwn]"; //变量值
try { //消除访问修饰符的限制
f[i].setAccessible(true);
} catch (SecurityException ex) {}
try {
v = f[i].get(obj); //变量值
if (v!=null) {
if (v instanceof String) { //给字符串加引号
v = "\"" + v + '\"';
} else if (v instanceof Character) { //给字符加单引号
char cv = ((Character)v).charValue();
if (cv<' ') {
StringBuffer sbv = new StringBuffer();
sbv.append("\\u");
sbv.append(Integer.toHexString((int)cv));
while(sbv.length()<6) { //补前导零
sbv.insert(2,'0');
}
v = sbv;
}
v = "\'" + v + '\'';
}
}
}catch (Exception ex) {}
Class ct = f[i].getType(); //变量类型
String t = formatClassName(ct,v);//变量类型名称
dump(indent(prefix) + (m + ' ' + t + ' ' + n).trim() + " = ",
depth,checkCircuit,v);
}
c = c.getSuperclass();
} //while end
dumpEnd(prefix,checkCircuit,obj);
}

/**
* 输出调试开始信息。
* @param prefix 输出前缀。
* @param dump的对象。
*/
private static void dumpBegin(String prefix,Vector checkCircuit,Object obj) {
String className = formatClassName(obj.getClass(),obj);
int address = System.identityHashCode(obj);
checkCircuit.addElement(new Integer(address));
if (obj instanceof Array) {
className = className.substring(2) + '[' + Array.getLength(obj) + "] ";
}
if (className.startsWith("java.lang.")) { //去掉缺省的包名
className = className.substring(10);
}
if (prefix.trim().endsWith("@" + address)) {
out.println(prefix + " {");
} else {
out.println(prefix + className + " @" + address + " {");
}
}

/**
* 对于复合对象，输出dump结束位置的大括号。
* @param prefix 输出前缀。
*/
private static void dumpEnd(String prefix,Vector checkCircuit,Object obj) {
checkCircuit.removeElement(new Integer(System.identityHashCode(obj)));
int p = prefix.lastIndexOf(indentString);
if (p>0) {
prefix = prefix.substring(0,p) + indentString;
}
for (int i=0;i<prefix.length();i++) {
char c = prefix.charAt(i);
if (c=='\t'|| c==' ') {
out.print(c);
} else {
break;
}
}
out.println("}");
out.flush();
}

/**
* 用于定位调用堆栈层次中调用本类某个方法(或者更高层次)时的位置。
* @param esc 调用堆栈中需要剔除的层次中的字符串，传入null表示无剔除层次。
* @return 位置信息(类、函数、代码行)。
*/
public static String locate(String esc) {
StringWriter sw = new StringWriter();
new Exception().printStackTrace(new PrintWriter(sw));
for (StringTokenizer st = new StringTokenizer(sw.toString(),"\n");
st.hasMoreTokens();) {
String str = st.nextToken();
if (str.indexOf("Exception")!=-1) { //异常描述，跳过
continue;
} else if (str.indexOf(Debug.class.getName())!=-1) { //调用栈最里层，跳过
continue;
} else if (esc!=null && str.indexOf(esc)!=-1) { //传入参数指定的层，跳过
continue;
} else if (esc==fullInfo) { //一个内部使用的特殊标记
return str;
} else {
int i = str.indexOf('(');
int j = str.indexOf(')');
if (i!=-1 && j!=-1) {
return str.substring(i,j+1);
}
break;
}
}
return "";
}

/**
* 将整数按16进制字符编码放到字节数组某个位置（0~9，a~f小写字母）。
* @param src 保存16进制字符的字节数组。
* @param lowByte 最低字节的位置（注意是最低字节的位置，在地址高字节端）。
* @param value 待转换成16进制数的整数值。
*/
private static void setHex(byte[]src, int lowByte, int value) {
for (int i=0;i<8;i++) {
src[lowByte-i] = hexNumber[value & 0xf]; //取低4位
value >>>= 4; //将value逻辑右移4bit
if (value==0) {
break;
}
}
}

/** 16进制编码函数setHex()使用的内部常量。*/
private static final byte[] hexNumber = {
(byte)'0',(byte)'1',(byte)'2',(byte)'3',(byte)'4',(byte)'5',(byte)'6',
(byte)'7',(byte)'8',(byte)'9',(byte)'a',(byte)'b',(byte)'c',(byte)'d',
(byte)'e',(byte)'f'
};

/**
* 缩进一级。
* @param prefix原来的前缀。
* @return 缩进后的前缀。
*/
private static String indent(String prefix) {
int p = prefix.lastIndexOf(indentString);
if (p>0) {
prefix = prefix.substring(0,p) + indentString;
}
StringBuffer sb = new StringBuffer();
for (int i=0;i<prefix.length();i++) {
char c = prefix.charAt(i);
if (c=='\t'|| c==' ') {
sb.append(c);
} else {
break;
}
}
sb.append(indentString);
return sb.toString();
}

/**
* 将类名格式化成符合Java语言风格。
* @param c 要格式化的类。
* @return 格式化后的类名。
*/
private static String formatClassName(Class c,Object obj) {
String t = c.getName();

//去掉末尾分号
if (t.charAt(t.length()-1)==';') {
t = t.substring(0,t.length()-1);
}

//数组类型处理
boolean isArray = false;
boolean firstDimension = true;
while (t.startsWith("[")) {
isArray = true;
if (firstDimension && obj!=null) { //是第一维
t = t.substring(1) + '[' + Array.getLength(obj) + ']';
firstDimension = false;
} else {
t = t.substring(1)+"[]";
}
}
if (isArray) {
char ch = t.charAt(0);
t = t.substring(1);
switch (ch) {
case 'B':
t = "byte" + t; break;
case 'C':
t = "char" + t; break;
case 'F':
t = "float" + t; break;
case 'I':
t = "int" + t; break;
case 'J':
t = "long" + t; break;
case 'S':
t = "short" + t; break;
case 'Z':
t = "boolean" + t; break;
}
}
if (t.startsWith("java.lang.")) { //去掉缺省包名
t = t.substring(10);
} else if (t.startsWith("class ")) {
t = t.substring(7);
}
return t;
}

/**
* 将字符串长度变为固定长（后面补空格），若长度已经等于或超过期望长度则
* 补成期望长度的整数倍。
* @param str 期望改变长度的字符串。
* @param len 期望的长度。
* @return 改变长度后的字符串。
*/
private static String fixLength(String str,int len) {
StringBuffer sb = new StringBuffer(len);
sb.append(str);
int n = len - str.length()%len;
for (int i=0;i<n;i++) {
sb.append(' ');
}
return sb.toString();
}

/**
* 外界调用dump时输出的头部信息。
* @return 头部信息。
*/
private static String dumpHead() {
StringBuffer sb = new StringBuffer();
sb.append(sdf.format(new Date()));
sb.append(locate(null));
sb.append(' ');
return sb.toString();
}

/**
* 根据前缀取得当前递归深度。
* @param prefix 输出前缀。
* @return 递归深度(最小为1)。
*/
private static int getDepth(String prefix) {
int count = 0;
int indentLen = indentString.length();
int i=-indentLen;
while (true) {
count ++;
i = prefix.indexOf(indentString,i+indentLen);
if (i<0) {
return count;
}
}
}
/** 输出调试信息时间的格式。*/
private static SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss.SSS");

/** 无任何意义，locate内部定位标志。*/
public static final String fullInfo = "!@*#~^?'/\""; //给locate使用的内部标记。
}

/**
* 断言失败时抛出的错误。只是简单从Error类继承。错误不是异常，系统不应该捕获的。
* 若系统抛出该错误说明有BUG。
*/
class AssertFailed extends Error {}