Log Mask

public class MaskedReflectionToStringBuilder extends ReflectionToStringBuilder {
    @Override
    protected Object getValue(Field field) throws IllegalArgumentException, IllegalAccessException {
        Object value = super.getValue(field);


        do{
            // output null field by default
            if(value == null) break;
            
            LogIgnore ignore = field.getAnnotation(LogIgnore.class);
            if(ignore != null){
                value = "<ignored>";
                break;
            }
            
            LogMask ann = field.getAnnotation(LogMask.class);
            if(ann == null) break;
            
            if(LogUtils.isSimpleType(value.getClass())){
                // simple type mask as string
                if(ann.value() == LogMaskType.SimpleMask){
                    value = LogUtils.markString(String.valueOf(value), ann.value().getMask());
                }else{
                    value = LogUtils.markFullString(String.valueOf(value), ann.value().getMask());
                }
            }else{
                // complex type marked as hash code
                value = String.valueOf(value.hashCode());
            }
        }while(false);


        return value;
    }

}

--------------------------------------------------------分割线--------------------------------------------------------

public final class LogUtils {
    public static char MARK_CHAR = '_';


    private final static Set<Class<?>> SIMPLE_TYPES = new HashSet<Class<?>>();


    static {
        SIMPLE_TYPES.add(Boolean.class);
        SIMPLE_TYPES.add(Character.class);
        SIMPLE_TYPES.add(Byte.class);
        SIMPLE_TYPES.add(Short.class);
        SIMPLE_TYPES.add(Integer.class);
        SIMPLE_TYPES.add(Long.class);
        SIMPLE_TYPES.add(Float.class);
        SIMPLE_TYPES.add(Double.class);
        SIMPLE_TYPES.add(String.class);
    }


    private LogUtils() {
    }


    public static boolean isSimpleType(Class<?> cls) {
        return SIMPLE_TYPES.contains(cls) || cls.isEnum();
    }


    public static String markFullString(String str, char mask) {
        return str != null ? StringUtils.repeat(String.valueOf(mask), str.length()) : str;
    }


    public static String markString(String ac) {
        return markString(ac, MARK_CHAR);
    }


    public static String markString(String ac, char delim) {
        char mask = delim;
        if (StringUtils.isBlank(ac)) {
            return StringUtils.EMPTY;
        }


        char[] acChars = ac.toCharArray();
        char latestChar = acChars[acChars.length - 1];


        if (acChars.length == 1) {
            return String.valueOf(mask);
        } else if (acChars.length == 2) {
            return String.valueOf(new char[] { acChars[0], mask });
        } else if (acChars.length == 3) {
            return String.valueOf(new char[] { acChars[0], mask, acChars[2] });
        } else {
            int countor = 2;
            boolean completed = false;
            while (!completed) {
                acChars[countor] = mask;
                acChars[countor + 1] = mask;
                countor = countor + 3;
                if (countor + 1 >= acChars.length) {
                    completed = true;
                }
            }


            if (acChars[acChars.length - 1] == mask) {
                acChars[acChars.length - 1] = latestChar;
            }


            return String.valueOf(acChars);
        }
    }
}