package com.best.javaSdk;
|
|
import com.best.javaSdk.converter.Converter;
|
import com.best.javaSdk.converter.impl.*;
|
import com.best.javaSdk.converter.util.jsonReader.*;
|
|
import org.w3c.dom.Document;
|
import org.w3c.dom.Element;
|
import org.w3c.dom.Node;
|
import org.w3c.dom.NodeList;
|
import org.xml.sax.InputSource;
|
|
import javax.xml.parsers.DocumentBuilder;
|
import javax.xml.parsers.DocumentBuilderFactory;
|
import java.io.StringReader;
|
import java.lang.reflect.Field;
|
import java.lang.reflect.ParameterizedType;
|
import java.lang.reflect.Type;
|
import java.util.*;
|
|
public class Parser {
|
|
private static Map<Class, Converter> converterMap;
|
|
static {
|
converterMap = new HashMap<>();
|
converterMap.put(String.class, new StringConverter());
|
converterMap.put(int.class, new IntConverter());
|
converterMap.put(Integer.class, new IntConverter());
|
converterMap.put(float.class, new FloatConverter());
|
converterMap.put(Float.class, new FloatConverter());
|
converterMap.put(double.class, new DoubleConverter());
|
converterMap.put(Double.class, new DoubleConverter());
|
converterMap.put(long.class, new LongConverter());
|
converterMap.put(Long.class, new LongConverter());
|
converterMap.put(boolean.class, new BooleanConverter());
|
converterMap.put(Boolean.class, new BooleanConverter());
|
converterMap.put(Date.class, new DateConverter());
|
}
|
|
public static String coverObject2Xml(Object o) {
|
StringBuilder sb = new StringBuilder("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
|
Class cls = o.getClass();
|
String className = cls.getName();
|
className = className.substring(className.lastIndexOf(".") + 1);
|
if (className.endsWith("Req")) {
|
sb.append(appendXmlNode("request", object2XmlConvert(o)));
|
} else {
|
sb.append(appendXmlNode("response", object2XmlConvert(o)));
|
}
|
|
return sb.toString();
|
}
|
|
public static String object2XmlConvert(Object o) {
|
StringBuilder stringBuilder = new StringBuilder();
|
try {
|
Class cls = o.getClass();
|
if (cls.getName().startsWith("java.lang")) {
|
return o.toString();
|
}
|
|
Field[] props = cls.getDeclaredFields();
|
for (Field prop : props) {
|
prop.setAccessible(true);
|
String propName = prop.getName();
|
Class propType = prop.getType();
|
Object propValue = prop.get(o);
|
StringBuilder stb = new StringBuilder();
|
if(propValue == null) {
|
continue;
|
}
|
if(converterMap.containsKey(propType)) {
|
stb = new StringBuilder(converterMap.get(propType).xmlReverse(propValue, prop));
|
} else if (propType.getName().equals("java.util.List")) {
|
List valueList = (List) propValue;
|
for (Object value : valueList) {
|
stb.append(appendXmlNode(propName, object2XmlConvert(value)));
|
}
|
} else {
|
stb = new StringBuilder(appendXmlNode(propName, object2XmlConvert(propValue)));
|
}
|
stringBuilder.append(stb);
|
}
|
} catch (Exception e) {
|
return "parser error : " + e.getMessage();
|
}
|
return stringBuilder.toString();
|
}
|
|
public static String appendXmlNode(String nodeName, String nodeValue) {
|
StringBuilder sb = new StringBuilder();
|
return sb.append("<").append(nodeName).append(">").append(nodeValue).append("</").append(nodeName).append(">").toString();
|
}
|
|
public static <T> T coverXml2Object(String xml, Class<T> clazz) {
|
|
if(xml == null || "".equals(xml)) {
|
return null;
|
}
|
|
try {
|
DocumentBuilderFactory factory = DocumentBuilderFactory
|
.newInstance();
|
DocumentBuilder builder = factory.newDocumentBuilder();
|
Document doc = builder.parse(new InputSource(new StringReader(xml)));
|
Element root = doc.getDocumentElement();
|
NodeList nodeList = root.getChildNodes();
|
return handelNodes(nodeList, clazz);
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
return null;
|
}
|
|
public static <T> T handelNodes(NodeList nodeList, Class<T> clazz) {
|
try {
|
if (nodeList == null) {
|
return null;
|
}
|
if (clazz.getName().startsWith("java.lang")) {
|
return (T)nodeList.item(0).getNodeValue();
|
}
|
|
T obj = clazz.newInstance();
|
Map<Field, List<Object>> listChildMap = new HashMap<>();
|
for (int i = 0; i < nodeList.getLength(); i++) {
|
Node node = nodeList.item(i);
|
String nodeName = node.getNodeName();
|
short nodeType = node.getNodeType();
|
if (nodeType == 3 || nodeType == 4) {
|
continue;
|
}
|
if(!node.hasChildNodes()) {
|
continue;
|
}
|
Field[] fields = clazz.getDeclaredFields();
|
if(!isContainProp(fields, nodeName)) {
|
continue;
|
}
|
Field field = clazz.getDeclaredField(nodeName);
|
field.setAccessible(true);
|
Class<?> fieldType = field.getType();
|
|
if (fieldType.getName().equals("java.util.List")) {
|
Type type = field.getGenericType();
|
if(type instanceof ParameterizedType) {
|
ParameterizedType pt = (ParameterizedType) type;
|
Class genericClazz = (Class) pt.getActualTypeArguments()[0];
|
Object listChildObj = handelNodes(node.getChildNodes(), genericClazz);
|
|
if (listChildMap.get(field) == null) {
|
List<Object> objectList = new ArrayList<>();
|
objectList.add(listChildObj);
|
listChildMap.put(field, objectList);
|
} else {
|
listChildMap.get(field).add(listChildObj);
|
}
|
}
|
} else {
|
Converter converter = converterMap.get(fieldType);
|
if (converter == null) {
|
field.set(obj, handelNodes(node.getChildNodes(), fieldType));
|
continue;
|
}
|
Object convert = converter.convertXml(node, field);
|
if (convert != null) {
|
field.set(obj, convert);
|
}
|
}
|
}
|
for (Field field : listChildMap.keySet()) {
|
field.set(obj, listChildMap.get(field));
|
}
|
return obj;
|
} catch (InstantiationException | IllegalAccessException | NoSuchFieldException e) {
|
e.printStackTrace();
|
}
|
return null;
|
}
|
|
public static <T> T convertJson2Object(String str, Class<T> clazz) {
|
try {
|
JSONReader reader = new JSONValidatingReader(new ExceptionErrorListener());
|
Object rootObj = reader.read(str);
|
return convertJson2Object(rootObj, clazz);
|
}catch (Exception e) {
|
e.printStackTrace();
|
}
|
return null;
|
}
|
|
private static <T> T convertJson2Object(Object object, Class<T> clazz) throws Exception {
|
T t = clazz.newInstance();
|
if (object instanceof Map<?, ?>) {
|
Map<?, ?> rootJson = (Map<?, ?>) object;
|
for (Object obj : rootJson.keySet()) {
|
String itemName = obj.toString();
|
Object itemValue = rootJson.get(obj);
|
Field[] fields = clazz.getDeclaredFields();
|
if (!isContainProp(fields, itemName)) {
|
continue;
|
}
|
Field field = clazz.getDeclaredField(itemName);
|
field.setAccessible(true);
|
Class<?> fieldType = field.getType();
|
Object value;
|
|
Converter converter = converterMap.get(fieldType);
|
if (converter == null && itemValue instanceof Map<?, ?>) {
|
value = convertJson2Object(itemValue, fieldType);
|
} else if (itemValue instanceof ArrayList<?> && fieldType.equals(List.class)) {
|
value = handlerListJson((ArrayList<?>) itemValue, field);
|
} else if (converter != null) {
|
if (itemValue == null) {
|
value = null;
|
} else {
|
value = converter.convertJson(itemValue, field);
|
}
|
} else {
|
continue;
|
}
|
if (value != null) {
|
field.set(t, value);
|
}
|
}
|
}
|
return t;
|
}
|
|
private static List handlerListJson(ArrayList<?> value, Field field) throws Exception {
|
List list = new ArrayList<>();
|
Type type = field.getGenericType();
|
if(type instanceof ParameterizedType) {
|
ParameterizedType pt = (ParameterizedType) type;
|
Class genericClazz = (Class) pt.getActualTypeArguments()[0];
|
Converter converter = converterMap.get(genericClazz);
|
for (Object object : value) {
|
if (object instanceof Map<?, ?>) {
|
list.add(convertJson2Object(object, genericClazz));
|
}else {
|
list.add(converter.convertJson(object, field));
|
}
|
}
|
}
|
|
return list;
|
}
|
|
public static String convertObject2Json(Object object) {
|
try {
|
JSONWriter jsonWriter = new JSONWriter();
|
return jsonWriter.write(object);
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
return null;
|
}
|
|
private static boolean isContainProp(Field[] fields, String nodeName) {
|
|
if(fields == null || fields.length < 0) {
|
return false;
|
}
|
|
if(nodeName == null || "".equals(nodeName)) {
|
return false;
|
}
|
|
for(Field field : fields) {
|
if(field.getName().equals(nodeName)) {
|
return true;
|
}
|
}
|
return false;
|
}
|
|
}
|
