公用toString方法

import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Pattern;

import javax.servlet.ServletRequest;

/**
 * 公用toString方法<br>
 * 将对象的以get为前缀的无参方法转化为字符串<br>
 * 主要用于输出日志信息<br>
 * 示例, 将User对象转换为字符串, 但地址不输出, 密码以*号输出<br>
 * new ToString(user).exclude("address").secrete("password").execute();
 * @author zhaohuihua
 * @version 2012-9-26
 * @since 1.0
 */
public class ToString {

    /**
     * 调试日志
     */
    private static Log log = new Log();

    /**
     * 默认最大缩进层次
     */
    private static final int MAX_INDENT = 3;
    /**
     * get方法正则表达式
     */
    private static final Pattern PTN_GETTER = Pattern.compile("^(?:get|is).+$");
    /**
     * 缩进符的正则表达式
     */
    private static final Pattern PTN_INDENT = Pattern
            .compile("([\\r\\n]+)(\\t*)");
	/**
     * 日期格式字符串
     */
    private static final String DATE_FORMAT = "yyyy-MM-dd HH:mm:ss.SSS";

    /**
     * 方法比较器, 用于方法按名称排序
     */
    private static final MethodComparator<Method> COMPARATOR = new MethodComparator<Method>();

    /**
     * 有一些特殊字符会影响日志的显示格式, 需要替换为文本形式, 在REPLACE中配置
     */
    private static final Map<Pattern, String> REPLACE = new HashMap<Pattern, String>();
    static {
        // 将回车符 换行符 制表符等替换为文本形式
        REPLACE.put(Pattern.compile("\\f"), "\\\\f");
        REPLACE.put(Pattern.compile("\\r"), "\\\\r");
        REPLACE.put(Pattern.compile("\\n"), "\\\\n");
        REPLACE.put(Pattern.compile("\\t"), "\\\\t");
    }
    /**
     * "getClass" 方法
     */
    private static Method getClass = null;
    static {
        try {
            getClass = Object.class.getMethod("getClass");
        } catch (Exception e) {
            log.warn("init Object.getClass() method error", e);
        }
    }

    /**
     * 待转化的对象
     */
    private Object target;
    /**
     * 缩进层次
     */
    private int indent;
    /**
     * 最大缩进层次
     */
    private int maxIndent;
    /**
     * 有一些字段不希望被输出, 在exclusion中配置
     */
    private List<String> exclusion;
    /**
     * 有一些内容需要保密, 在secrecy中配置
     */
    private List<String> secrecy;

    /**
     * 构造函数
     * @param object待转化的对象
     */
    public ToString(Object object) {
        this(object, MAX_INDENT);
    }

    /**
     * 构造函数
     * @param target 待转化的对象
     * @param indent 最大缩进层次
     */
    public ToString(Object target, int indent) {
        this.target = target;
        this.maxIndent = indent;
        this.exclusion = new ArrayList<String>();
        this.secrecy = new ArrayList<String>();
    }

    /**
     * 有一些字段不希望被输出, 通过这个方法排除
     * @param fields 字段名, 用字段名可匹配方法名和Map中的KEY<br>
     *        如address, 会排除getAddress()方法, 以及Map中KEY=address的值<br>
     *        注意: 这里并不会真正的去取字段名, 只是简单的将首字母大写再加上get|is
     * @return 返回当前对象, 用于连续调用
     */
    public ToString exclude(String... fields) {
        for (String getter : fields) {
            exclusion.add(getter);
        }
        return this;
    }

    /**
     * 有一些内容需要保密, 通过这个方法设置, 设置后将以*号代替内容
     * @param fields 字段名, 用字段名可匹配方法名和Map中的KEY<br>
     *        如password, 会保密getPassword()方法, 以及Map中KEY=password的值<br>
     *        注意: 这里并不会真正的去取字段名, 只是简单的将首字母大写再加上get|is
     * @return 返回当前对象, 用于连续调用
     */
    public ToString secrete(String... fields) {
        for (String getter : fields) {
            secrecy.add(getter);
        }
        return this;
    }

    /**
     * 将对象的以get为前缀的无参方法转化为字符串<br>
     * 主要用于输出日志信息<br>
     * @return String
     */
    public String execute() {
        if (target == null) {
            return null;
        }
        try {
            return toString(target);
        } catch (Exception e) {
            log.warn("To string error", e);
            return ((Object) target).toString();
        }
    }

    /**
     * 将对象的以get为前缀的无参方法转化为字符串
     * @param object 待转化的对象
     * @return String
     */
    @SuppressWarnings("unchecked")
    private String toString(Object object) {
        if (object == null) {
            return null;
        }

        Class<?> clazz = object.getClass();
        if (clazz.isArray()) { // 数组
            return arrayToString(object);
        } else if (CharSequence.class.isAssignableFrom(clazz)
                || clazz == Character.class) { // 字符类型或字符串类型
            return replace(object);
        } else if (clazz == Integer.class || clazz == Long.class
                || clazz == Short.class || clazz == Double.class
                || clazz == Float.class || clazz == Boolean.class
                || clazz == Byte.class) { // 基本类型及其包装类型
            return object.toString();
        } else if (clazz == Class.class) { // Class类型
            return getClassName(object);
        } else if (Date.class.isAssignableFrom(clazz)) { // 日期类型
            DateFormat formater = new SimpleDateFormat(DATE_FORMAT);
            return formater.format((Date) object);
        } else if (Collection.class.isAssignableFrom(clazz)) { // Collection类型
            return toString((Collection<?>) object);
        } else if (object != target && Enabled.class.isAssignableFrom(clazz)) {
            // 已经实现了ToString接口的类型
            String str = object.toString();
            // 增加缩进
            return PTN_INDENT.matcher(str).replaceAll("$1\t$2");
        }

        // 以下为复杂类型, 需要增加缩进了
        if (indent + 1 > maxIndent) { // 递归次数太多则不再转化
            return replace(object.toString());
        }
        indent++;
        String string;
        if (Map.class.isAssignableFrom(clazz)) { // Map类型
            string = toString((Map<Object, Object>) object);
        } else if (ServletRequest.class.isAssignableFrom(clazz)) {
            // ServletRequest类型
            Map map = ((ServletRequest) object).getParameterMap();
            string = toString(map);
        } else {
            // 其他类型
            // 将该对象的类及其父类的所有字段转换为字符串
            // 并将字段值按照对象的处理方式作递归转换
            List<Method> methods = getGetterList(object);
            string = toString(object, methods);
        }
        indent--;
        return string;
    }
    /**
     * 将对象的以get为前缀的无参方法转化为字符串<br>
     * @param object 待转化的对象
     * @param methods 指定的方法列表
     * @return String
     */
    private String toString(Object object, List<Method> methods) {
        if (object == null) {
            return null;
        }
        StringBuilder buffer = new StringBuilder();
        StringBuilder message = new StringBuilder();
        // 遍历方法列表, 依次调用对象的指定方法, 获取返回值
        for (Method method : methods) {
            if (method == null) {
                continue;
            }
            // 排除Static修饰符的方法和非公有的方法
            int modifier = method.getModifiers();
            if (Modifier.isStatic(modifier) || !Modifier.isPublic(modifier)) {
                continue;
            }
            String methodName = method.getName();
            if (method.getReturnType() == void.class // 没有返回结果
                    || method.getParameterTypes().length > 0 // 有参数
                    || !PTN_GETTER.matcher(methodName).matches()) { // 不是get方法
                continue;
            }
            try {
                if (buffer.length() > 0) {
                    buffer.append(", \r\n");
                }
                int index = methodName.startsWith("get") ? 3 : 2;
                // 打印缩进
                for (int i = 0; i < indent; i++) {
                    buffer.append("\t");
                }
                buffer.append(methodName.substring(index)).append(" = ");

                // 调用相应的方法获取返回结果
                if (isSecretMethod(methodName)) { // 保密的方法, 不再求值
                    buffer.append(toPassword(method.getReturnType()));
                    continue;
                }

                Object result = method.invoke(object, new Object[0]);
                Class<?> rclass = result == null ? null : result.getClass();
                // 获取被调用方法的返回值
                if (result == null) {
                    buffer.append("null");
                } else if (Class.class.isAssignableFrom(rclass)) { // Class类型
                    buffer.append(getClassName(object));
                } else if (CharSequence.class.isAssignableFrom(rclass)) {
                    buffer.append(replace(result));
                } else {
                    // 递归调用
                    buffer.append(toString(result));
                }
            } catch (Exception e) {
                if (message.length() > 0) {
                    message.append(", ");
                }
                message.append("Method:[").append(methodName).append("], ")
                        .append(getClassName(e))
                        .append(":[").append(e.getMessage()).append("]");
            }
        }
        if (message.length() > 0) { // 有失败的部分
            message.insert(0, "Get value is failed, ")
                .append("Class:[").append(getClassName(object)).append("], ");
            log.warn(message.toString());
        }
        // 打印换行, 缩进
        buffer.append("\r\n");
        for (int i = 0; i < indent - 1; i++) {
            buffer.append("\t");
        }
        return buffer.insert(0, "{\r\n").append("}").toString();
    }

    private String toString(final Collection<?> list) {
        if (list == null) {
            return "null";
        }
        int length = list.size();
        if (length == 0) {
            return "[]";
        }
        int i = 0;
        StringBuilder buffer = new StringBuilder();
        for (Object item : list) {
            if (i++ >= 20) { // 太长则截断
                buffer.append(", ... (").append(length).append(") ");
                break;
            }
            if (buffer.length() > 0) {
                buffer.append(", ");
            }
            buffer.append(toString(item));
        }
        return buffer.insert(0, "[").append("]").toString();
    }

    private String toString(final Map<Object, Object> map) {
        if (map == null) {
            return "null";
        }
        if (map.size() == 0) {
            return "[]";
        }
        StringBuilder buffer = new StringBuilder();
        Set<Map.Entry<Object, Object>> set = map.entrySet();
        for (Map.Entry<Object, Object> entry : set) {
            Object key = entry.getKey();
            Object value = entry.getValue();
            if (key == null) {
                continue;
            }
            if (isExcludeKey(key)) { // 被排除的KEY
                continue;
            }
            if (buffer.length() > 0) {
                buffer.append(", \r\n");
            }
            // 打印缩进
            for (int i = 0; i < indent; i++) {
                buffer.append("\t");
            }
            buffer.append(key).append(" = ");
            if (isSecretKey(key)) { // 保密的KEY
                buffer.append(toPassword(value)); // 输出*号
            } else {
                buffer.append(toString(value));
            }
        }
        // 打印换行, 缩进
        buffer.append("\r\n");
        for (int i = 0; i < indent - 1; i++) {
            buffer.append("\t");
        }
        return buffer.insert(0, "{\r\n").append("}").toString();
    }

    /**
     * 数组转换为字符串
     * @param array 数组
     * @return 字符串
     */
    private String arrayToString(final Object array) {
        if (array == null) {
            return "null";
        }
        if (!array.getClass().isArray()) {
            return toString(array);
        }
        int length = Array.getLength(array);
        if (length == 0) {
            return "[]";
        }
        StringBuilder buffer = new StringBuilder();
        for (int i = 0; i < length; i++) {
            if (i >= 20) { // 太长则截断
                buffer.append(", ... (").append(length).append(") ");
                break;
            }
            if (buffer.length() > 0) {
                buffer.append(", ");
            }
            buffer.append(toString(Array.get(array, i)));
        }
        return buffer.insert(0, "[").append("]").toString();
    }

    /**
     * 输出保密字符串
     * @param src 字符串
     * @return 保密字符串
     */
    private String toPassword(Object src) {
        if (src == null) return null;
        return toPassword(src.getClass());
    }

    /**
     * 输出保密字符串
     * @param clazz Class
     * @return 保密字符串
     */
    private String toPassword(Class<?> clazz) {
        if (clazz == null) return null;
        if (clazz.isArray()) { // 是数组
            return "[******]";
        } else {
            return "******";
        }
    }

    /**
     * 判断KEY是否为保密字段
     * @param key 字段
     * @return 是否为保密字段
     */
    private boolean isSecretKey(Object key) {
        return isSpecialKey(secrecy, key);
    }

    /**
     * 判断对象的方法是否为保密方法
     * @param method 方法名称
     * @return 是否为保密方法
     */
    private boolean isSecretMethod(Object method) {
        return isSpecialMethod(secrecy, method);
    }

    /**
     * 判断KEY是否为被排除字段
     * @param key 字段
     * @return 是否为被排除字段
     */
    private boolean isExcludeKey(Object key) {
        return isSpecialKey(exclusion, key);
    }

    /**
     * 判断对象的方法是否为被排除方法
     * @param method 方法名称
     * @return 是否为被排除方法
     */
    private boolean isExcludeMethod(Object method) {
        return isSpecialMethod(exclusion, method);
    }

    /**
     * 判断KEY是否为被排除或保密字段
     * @param list List
     * @param key 字段
     * @return 是否为被排除或保密字段
     */
    private boolean isSpecialKey(List<String> list, Object key) {
        if (key == null) return false;
        // 判断KEY是否为被排除或保密字段
        for (String name : list) {
            if (key.equals(name)) {
                return true; // 排除
            }
        }
        return false;
    }

    /**
     * 判断对象的方法是否为被排除或保密方法
     * @param list List
     * @param method 方法名称
     * @return 是否为被排除或保密方法
     */
    private boolean isSpecialMethod(List<String> list, Object method) {
        if (method == null)
            return false;
        // 判断方法名是否为被排除或保密字段
        for (String getter : list) {
            String name = getter;
            char initial = getter.charAt(0);
            if (initial >= 'a' && initial <= 'z') { // 首字母是小写字母转化为大写
                String lower = String.valueOf(initial);
                String upper = lower.toUpperCase();
                name = name.replaceFirst(lower, upper);
            }
            if (method.equals("get" + name)) {
                return true; // 排除或保密
            }
            if (method.equals("is" + name)) {
                return true; // 排除或保密
            }
        }
        return false;
    }

    /**
     * 将特殊字符替换为文本形式
     * @param obj 待转换的对象
     * @return 转换后的字符串
     */
    private String replace(Object obj) {
        if (obj == null) {
            return null;
        }
        String string = obj.toString();
        // 将特殊字符替换为文本形式
        Iterator<Map.Entry<Pattern, String>> iterator =
            REPLACE.entrySet().iterator();
        while (iterator.hasNext()) { // 遍历Map
            Map.Entry<Pattern, String> entry = iterator.next();
            Pattern pattern = entry.getKey();
            String replacement = entry.getValue();
            string = pattern.matcher(string).replaceAll(replacement);
        }
        if (string.length() > 60) { // 大于60则截取前50个字符
            string = new StringBuilder()
                .append(string.substring(0, 50)).append("... ")
                .append("(").append(string.length()).append(")")
                .toString();
        }
        return string;
    }

    /**
     * 获取指定对象的get方法列表
     * @param object Object
     * @return List<Method>
     */
    private List<Method> getGetterList(Object object) {
        if (object == null) return null;

        // 获取实例的类
        Class<?> clazz = object.getClass();
        // 类的所有方法
        Method[] methodAll = clazz.getMethods();
        // 筛选后的方法
        List<Method> list = new ArrayList<Method>();
        // 遍历所有方法, 只取有返回结果,无参数的get方法
        // 并剔除在被排除方法之列的
        for (Method method : methodAll) {
            if (method == null) continue;
            String methodName = method.getName();
            if (getClass.getName().equals(methodName)) continue;
            if (method.getReturnType() == void.class // 没有返回结果
                    || method.getParameterTypes().length > 0 // 有参数
                    || !PTN_GETTER.matcher(methodName).matches()) { // 不是get方法
                continue;
            }
            if (isExcludeMethod(methodName)) continue;
            list.add(method);
        }
        // 以方法名排序
        Collections.sort(list, COMPARATOR);
        list.add(0, getClass);
        return list;
    }

    private String getClassName(Object obj) {
        if (obj == null) return "null";
        StringBuilder array = new StringBuilder();
        Class<?> clazz;
        if (obj.getClass() == Class.class) {
            clazz = (Class<?>) obj;
        } else {
            clazz = obj.getClass();
        }
        while (clazz.isArray()) {
            clazz = clazz.getComponentType();
            array.append("[]");
        }
        String className = clazz.getName();
        int index = className.lastIndexOf('.') + 1;
        return className.substring(index) + array.toString();
    }

    /**
     * 将对象的以get为前缀的无参方法转化为字符串<br>
     * 主要用于输出日志信息<br>
     * @return String
     */
    public String toString() {
        return this.execute();
    }

    /**
     * 方法比较器, 按照方法名称比较
     */
    private static class MethodComparator<T> implements Comparator<T> {

        public int compare(T o1, T o2) {
            if (o1 instanceof Method && o2 instanceof Method) {
                return ((Method)o1).getName().compareTo(((Method)o2).getName());
            }
            return 0;
        }
    }

    private static class Log {
        public void warn(String msg) {
            System.out.println("[WARN]" + msg);
        }
        public void warn(String msg, Throwable e) {
            System.out.println("[WARN]" + msg);
            e.printStackTrace();
        }
    }

    /**
     * ToString的标记接口<br>
     * 如果xxx已经实现该接口, 则new ToString(xxx)时直接调用xxx.toString()方法
     * @author  zhaohuihua
     * @version  2012-10-23
     */
    public interface Enabled { }

    /**
     * 测试方法
     * @param args 输入参数
     */
    public static void main(String[] args) {
        System.out.println(new ToString(new char[] {'a', '=', '\\', '\n'}));

        System.out.println();

        Map<String, Color> map = new HashMap<String, Color>();
        map.put("black", Color.BLACK);
        map.put("red", Color.RED);
        map.put("blue", Color.BLUE);
        map.put("green", Color.GREEN);
        String string = new ToString(map, 4)
            .exclude("black").secrete("matrix").execute();
        System.out.println(string);
    }
}