Java reflection principle makes object printing tool
- 2020-04-01 04:29:09
- OfStack
Mainly USES the Java reflection principle, formats the output Java object property value, especially the list and the map.
MyTestUtil. Java
package utils;
import java.lang.reflect.Field;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
/**
* This class is convenient for console output object , main applications java Reflection mechanism. Because of usability and aesthetics, infinite recursion is not used.
* But in the toStr Add one to the method boolean recursion , whether it's recursive or not.
* Of course, we can also boolean recursion Switch to int recursion , to control the number of recursion.
* In fact, in my experience, complex data toString with json Tool conversion to json Output is a good way.
//That's the way I did it, whether a Boolean recursion is recursive or not
public static int add(int i,boolean recursion){
sum+=i;
if(recursion)
add(i, false);
return sum;
}
//Also, int recursion represents the number of recursions
public static int add(int i,int recursion){
sum+=i;
if(recursion>0){
recursion--;
add(i, recursion);
}
return sum;
}
*
*
* @author klguang
*
*/
public class MyTestUtil {
static final String SPLIT_LINE = "=";//The divider
static final String MY_SIGN = "KLG_print";//Merlin � � �
private static String DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";
private static String collectionToStr(Object object, boolean recursion) {
if (object == null)
return "null";
Object[] a = null;
//Converts a collection type to an array type
if (isArrayType(object))
a = (Object[]) object;
else
a = ((Collection) object).toArray();
if (isSimpleArr(a) || !recursion)
return Arrays.toString(a);
else
return complexArrToStr(a);
}
private static String complexArrToStr(Object[] a) {
if (a == null)
return "null";
int iMax = a.length - 1;
if (iMax == -1)
return "[]";
StringBuilder b = new StringBuilder();
for (int i = 0;; i++) {
String value = objToStr(a[i], false);
b.append("[" + i + "]" + " -> " + value);
if (i == iMax)
return b.toString();
b.append(", rn");
}
}
private static String mapToStr(Map<String, Object> map, boolean recursion) {
if (map == null)
return "null";
if (isSimpleMap(map) || !recursion)
return simpleMapToStr(map);
else
return complexMapToStr(map, true);
}
private static String simpleMapToStr(Map map) {
Iterator<Entry<String, Object>> i = map.entrySet().iterator();
if (!i.hasNext())
return "{}";
StringBuilder sb = new StringBuilder();
sb.append('{');
for (int t = 1;; t++) {
Entry<String, Object> e = i.next();
sb.append(e.getKey()).append(" = ").append(e.getValue());
if (!i.hasNext())
return sb.append('}').toString();
sb.append(',').append(' ');
if (t % 10 == 0 && t != 0)
sb.append("rn ");
}
}
private static String complexMapToStr(Map map, boolean recursion) {
Iterator<Entry<String, Object>> i = map.entrySet().iterator();
if (!i.hasNext())
return "{}";
StringBuilder sb = new StringBuilder();
sb.append("{rn");
for (int t = 1;; t++) {
Entry<String, Object> e = i.next();
String key = String.valueOf(e.getKey());
Object value = e.getValue();
sb.append(indent(2," ")).append(key).append(" = ");
if (isSimpleType(value) || !recursion)
sb.append(String.valueOf(value));
else
sb.append(objToStr(value, false));
if (!i.hasNext())
return sb.append("rn}").toString();
sb.append(',').append("rn");
}
}
private static String beanToStr(Object object, boolean recursion) {
if (object == null)
return "null";
Class clazz = object.getClass();
StringBuilder sb = new StringBuilder();
//Returns the abbreviation of the underlying class given in the source code
sb.append(clazz.getSimpleName()).append("[");
Field[] fields = sortFieldByType(clazz.getDeclaredFields());
int iMax = fields.length - 1;
if (iMax == -1)
return sb.append("]").toString();
for (int i = 0;; i++) {
Field field = fields[i];
field.setAccessible(true);//Setting some properties is accessible
String name = field.getName();//Get the name of the field
if (name.equals("serialVersionUID"))
continue;
try {
Object value = field.get(object);//Gets the value of this property
if (isSimpleType(value) || !recursion)
sb.append(name + " = " + String.valueOf(value));
else
sb.append("rn" + indent(clazz.getSimpleName().length() + 2," ")
+ objToStr(value, false) + "rn");
} catch (Exception e) {
e.printStackTrace();
}
if (i == iMax)
return sb.append("]").toString();
sb.append(",");
}
}
private static String indent(int length,String sign) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < length; i++) {
sb.append(sign);
}
return sb.toString();
}
private static boolean isSimpleType(Object obj) {
if (obj == null)
return true;
else {
Class objectClass = obj.getClass();
return isSimpleType(objectClass);
}
}
private static boolean isSimpleType(Class objectClass) {
if (objectClass == boolean.class || objectClass == Boolean.class
|| objectClass == short.class || objectClass == Short.class
|| objectClass == byte.class || objectClass == Byte.class
|| objectClass == int.class || objectClass == Integer.class
|| objectClass == long.class || objectClass == Long.class
|| objectClass == float.class || objectClass == Float.class
|| objectClass == char.class || objectClass == Character.class
|| objectClass == double.class || objectClass == Double.class
|| objectClass == String.class) {
return true;
} else {
return false;
}
}
private static boolean isCollectionType(Object obj) {
if (obj == null)
return false;
return (obj.getClass().isArray() || (obj instanceof Collection));
}
private static boolean isArrayType(Object obj) {
if (obj == null)
return false;
return (obj.getClass().isArray());
}
private static boolean isMapType(Object obj) {
if (obj == null)
return false;
return (obj instanceof Map);
}
private static boolean isDateType(Object obj){
if(obj==null)
return false;
return (obj instanceof Date);
}
private static boolean isBeanType(Object obj) {
if (isSimpleType(obj) || isCollectionType(obj) || isMapType(obj))
return false;
else
return true;
}
private static boolean isSimpleArr(Object[] a) {
if (a == null || a.length < 1)
return true;
boolean flag = true;
for (Object o : a) {
if (!isSimpleType(o)) {
flag = false;
break;
}
}
return flag;
}
private static boolean isSimpleMap(Map map) {
if (map == null)
return true;
Iterator<Entry<String, Object>> i = map.entrySet().iterator();
boolean flag = true;
while (i.hasNext()) {
Entry<String, Object> e = i.next();
if (!isSimpleType(e.getValue())) {
flag = false;
break;
}
}
return flag;
}
public static Field[] sortFieldByType(Field[] fields) {
for (int i = 0; i < fields.length; i++) {
if (isSimpleType(fields[i].getType()))
continue;//Fields [I] is a simple type regardless
//Fields [I] is a complex type
//Int j = I +1, compare after fields[I]
for (int j = i + 1; j < fields.length; j++) {
Field fieldTmp = null;
if (isSimpleType(fields[j].getType())) {//Interacts with the first simple type that follows
fieldTmp = fields[i];
fields[i] = fields[j];
fields[j] = fieldTmp;
break; //The following loop is meaningless DE
}
}
}
return fields;
}
private static String objToStr(Object object, boolean recursion) {
if (object == null)
return "null";
object.toString();
if(isDateType(object))
return new SimpleDateFormat(DATE_FORMAT).format((Date)object);
else if (isBeanType(object))
return beanToStr(object, recursion);
else if (isCollectionType(object))
return collectionToStr(object, recursion);
else if (isMapType(object))
return mapToStr((Map) object, recursion);
else
return String.valueOf(object);
}
public static String objToStr(Object obj) {
return objToStr(obj, true);
}
private static void print(Object obj,String sign,String content) {
String begin=indent(15, SPLIT_LINE) + " " +obj.getClass().getSimpleName()
+ " >> " + sign + " " + indent(10, SPLIT_LINE);
int length=(begin.length()-sign.length()-5)/2;
String end=indent(length, SPLIT_LINE)+ " " + sign + " " + indent(length, SPLIT_LINE);
System.out.println(begin+"rn"+content+"rn"+end);
}
public static void print(Object obj){
print(obj,MY_SIGN,objToStr(obj));
}
public static void printWithSign(String sign, Object obj) {
print(obj, sign,objToStr(obj));
}
}
However, the above code is too cumbersome to consider multiple types of nesting.
The strong array type transfers to ClassCastException.
Writing a tool using log4j is much clearer than this.
public static void debug(String message,Object o){
int count=0;
if(o==null){
LOGGER.debug(chain(message,": null"));
return;
}
if(o.getClass().isArray()){
for(int i=0,len=Array.getLength(o);i<len;i++){
debug(chain(message,"-[",i,"]"),Array.get(o, i));
}
}else if(o instanceof Map){
Entry<?,?> e;
for(Iterator<?> it=((Map<?,?>)o).entrySet().iterator();it.hasNext();){
e=(Entry<?,?>) it.next();
debug(chain(message,"-[K:",e.getKey(),"]"),e.getValue());
}
}else if(o instanceof Iterable){
for(Iterator<?> it=((Iterable<?>) o).iterator();it.hasNext();){
count++;
debug(chain(message,"-[",count,"]"),it.next());
}
}else{
LOGGER.debug(chain(message,":",o));
}
}