347 lines
10 KiB
Plaintext
Executable File
347 lines
10 KiB
Plaintext
Executable File
package com.fp.dto.json;
|
|
|
|
import java.io.Serializable;
|
|
import java.lang.reflect.Field;
|
|
import java.lang.reflect.InvocationTargetException;
|
|
import java.math.BigDecimal;
|
|
import java.sql.Date;
|
|
import java.sql.Timestamp;
|
|
import java.text.ParseException;
|
|
import java.text.SimpleDateFormat;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
|
|
import net.sf.ezmorph.Morpher;
|
|
import net.sf.ezmorph.MorpherRegistry;
|
|
import net.sf.ezmorph.bean.MorphDynaBean;
|
|
import net.sf.json.JSONObject;
|
|
import net.sf.json.JsonConfig;
|
|
import net.sf.json.util.JSONUtils;
|
|
import net.sf.json.xml.XMLSerializer;
|
|
|
|
import org.apache.commons.beanutils.DynaProperty;
|
|
import org.apache.commons.beanutils.PropertyUtils;
|
|
|
|
import com.fp.common.helper.BeanManager;
|
|
import com.fp.common.logger.APPLogger;
|
|
import com.fp.dto.AbstractData;
|
|
import com.fp.dto.AbstractDataTransport;
|
|
import com.fp.dto.Response;
|
|
import com.fp.dto.json.morpher.DateMorpher;
|
|
import com.fp.dto.json.morpher.TimestampMorpher;
|
|
import com.fp.dto.save.SaveBean;
|
|
import com.fp.dto.save.SaveRequest;
|
|
|
|
public class Serializer {
|
|
|
|
private Serializable data;
|
|
|
|
private String json;
|
|
|
|
private JSONObject jsonObj;
|
|
|
|
private JsonConfig jsonConfig;
|
|
|
|
private MorpherRegistry morpherRegistry;
|
|
|
|
public Serializer(Serializable pData) throws Exception {
|
|
if (pData instanceof Response) {
|
|
((Response) pData).changeAbstractBeanToMap();
|
|
}
|
|
this.data = pData;
|
|
this.config();
|
|
}
|
|
|
|
public Serializer(String pXML, boolean pIndex) {
|
|
this("" + new XMLSerializer().read(pXML));
|
|
}
|
|
|
|
public Serializer(String pJSON) {
|
|
this.json = pJSON.trim();
|
|
this.config();
|
|
if ((this.json.charAt(0) == '"') && (this.json.charAt(this.json.length() - 1) == '"')) {
|
|
this.json = this.json.substring(1, this.json.length() - 1);
|
|
}
|
|
this.jsonObj = JSONObject.fromObject(this.json, this.jsonConfig);
|
|
}
|
|
|
|
private void config() {
|
|
this.jsonConfig = new JsonConfig();
|
|
this.jsonConfig.registerJsonValueProcessor(Date.class, new DateValueProcessor());
|
|
this.jsonConfig.registerJsonValueProcessor(Timestamp.class, new DateValueProcessor());
|
|
this.jsonConfig.registerDefaultValueProcessor(Double.class, new ObjectValueProcessor());
|
|
this.morpherRegistry = JSONUtils.getMorpherRegistry();
|
|
Morpher dynaMorpher = new TimestampMorpher();
|
|
this.morpherRegistry.registerMorpher(dynaMorpher);
|
|
dynaMorpher = new DateMorpher();
|
|
this.morpherRegistry.registerMorpher(dynaMorpher);
|
|
}
|
|
|
|
/**
|
|
* Entrega un string en formato json.
|
|
*
|
|
* @return String
|
|
* @throws Exception
|
|
*/
|
|
public final String toJSON() throws Exception {
|
|
try {
|
|
JSONObject jsonData = JSONObject.fromObject(this.data, this.jsonConfig);
|
|
return jsonData.toString();
|
|
} catch (Exception e) {
|
|
APPLogger.getLogger().error(e, e);
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
public String toXML() throws Exception {
|
|
try {
|
|
JSONObject jsonData = JSONObject.fromObject(this.data, this.jsonConfig);
|
|
XMLSerializer xml = new XMLSerializer();
|
|
xml.setElementName("REGISTRO");
|
|
xml.setObjectName("FP");
|
|
xml.setTrimSpaces(true);
|
|
xml.setRemoveNamespacePrefixFromElements(true);
|
|
xml.setSkipWhitespace(true);
|
|
xml.setSkipNamespaces(true);
|
|
String sXML = xml.write(jsonData);
|
|
while (sXML.indexOf("null=\"true\"/>") > 0) {
|
|
String aux1 = sXML.substring(0, sXML.indexOf("null=\"true\"/>"));
|
|
String aux2 = sXML.substring(sXML.indexOf("null=\"true\"/>") + 13);
|
|
sXML = aux1.substring(0, aux1.lastIndexOf("<")) + aux2;
|
|
}
|
|
return sXML;
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
public Object toObject(Class pType) throws Exception {
|
|
Object obj = JSONObject.toBean(this.jsonObj, pType);
|
|
if (obj instanceof Map) {
|
|
Map m = (Map) obj;
|
|
if (!m.containsKey("transportBeanClass")) {
|
|
m.put("transportBeanClass", pType.getName());
|
|
}
|
|
// m=this.correctMap(m);
|
|
obj = this.manageMapBean(m);
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
public <T> T toObjectGenerics(T pType) throws Exception {
|
|
T obj = (T) JSONObject.toBean(this.jsonObj, pType.getClass());
|
|
if (obj instanceof Map) {
|
|
Map m = (Map) obj;
|
|
if (!m.containsKey("transportBeanClass")) {
|
|
m.put("transportBeanClass", pType.getClass().getName());
|
|
}
|
|
// m=this.correctMap(m);
|
|
obj = (T) this.manageMapBean(m);
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
private List<Object> manageList(List<Object> pList) throws ClassNotFoundException, InstantiationException, IllegalAccessException,
|
|
InvocationTargetException, NoSuchMethodException, ParseException {
|
|
List<Object> dataList = new ArrayList<Object>();
|
|
for (Object obj : pList) {
|
|
dataList.add(this.manageValue(obj, null));
|
|
}
|
|
return dataList;
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
private Object manageValue(Object pObject, Class pType) throws ClassNotFoundException, InstantiationException, IllegalAccessException,
|
|
InvocationTargetException, NoSuchMethodException, ParseException {
|
|
if (pObject == null) {
|
|
return null;
|
|
}
|
|
if (pObject instanceof String) {
|
|
if (((String) pObject).compareTo("null") == 0) {
|
|
return null;
|
|
}
|
|
}
|
|
if (pObject instanceof JSONObject) {
|
|
JSONObject obj = (JSONObject) pObject;
|
|
if (obj.isNullObject()) {
|
|
return null;
|
|
}
|
|
}
|
|
if (pType != null) {
|
|
// System.out.println(pObject+" "+"->"+pType.getName());
|
|
return BeanManager.convertObject(pObject, pType);
|
|
}
|
|
if (pObject instanceof Double) {
|
|
return new BigDecimal("" + pObject);
|
|
}
|
|
if (pObject instanceof Map) {
|
|
Map m = (Map) pObject;// this.correctMap((Map)pObject);
|
|
return this.manageMapBean(m);
|
|
}
|
|
if (pObject instanceof MorphDynaBean) {
|
|
return this.manageBean((MorphDynaBean) pObject);
|
|
}
|
|
if (pObject instanceof List) {
|
|
return this.manageList((List) pObject);
|
|
}
|
|
if (pObject instanceof String) {
|
|
String sObj = (String) pObject;
|
|
if (sObj.length() == DateValueProcessor.DATE_TRANSPORT.length()) {
|
|
try {
|
|
return new Date(new SimpleDateFormat(DateValueProcessor.DATE_TRANSPORT).parse(sObj).getTime());
|
|
} catch (Exception e) {
|
|
}
|
|
}
|
|
if (sObj.length() == DateValueProcessor.TIMESTAMP_TRANSPORT.length()) {
|
|
try {
|
|
return new Timestamp(new SimpleDateFormat(DateValueProcessor.TIMESTAMP_TRANSPORT).parse(sObj).getTime());
|
|
} catch (Exception e) {
|
|
}
|
|
}
|
|
return pObject;
|
|
}
|
|
return pObject;
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
private Object manageBean(MorphDynaBean pMorphDynaBean) throws ClassNotFoundException, InstantiationException, IllegalAccessException,
|
|
InvocationTargetException, NoSuchMethodException {
|
|
DynaProperty[] prop = pMorphDynaBean.getDynaClass().getDynaProperties();
|
|
Map mapBean = new HashMap();
|
|
for (DynaProperty dynaProperty : prop) {
|
|
String name = dynaProperty.getName();
|
|
mapBean.put(name, pMorphDynaBean.get(name));
|
|
}
|
|
if (!mapBean.containsKey("transportBeanClass")) {
|
|
mapBean.put("transportBeanClass", "java.util.HashMap");
|
|
}
|
|
return this.manageMapBean(mapBean);
|
|
}
|
|
|
|
private String correctType(String pType) {
|
|
if (pType.compareTo("java.util.List") == 0) {
|
|
return "java.util.ArrayList";
|
|
}
|
|
if (pType.compareTo("java.util.Map") == 0) {
|
|
return "java.util.HashMap";
|
|
}
|
|
return pType;
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
private Object manageMapBean(Map pMapBean) throws ClassNotFoundException, InstantiationException, IllegalAccessException,
|
|
InvocationTargetException, NoSuchMethodException {
|
|
String classType = (String) pMapBean.get("transportBeanClass");
|
|
if (classType == null) {
|
|
return pMapBean;
|
|
}
|
|
classType = this.correctType(classType);
|
|
Object obj = Class.forName(classType).newInstance();
|
|
Set keys = pMapBean.keySet();
|
|
for (Object key : keys) {
|
|
String name = (String) key;
|
|
if (name.compareTo("transportBeanClass") == 0) {
|
|
continue;
|
|
}
|
|
try {
|
|
Class type = PropertyUtils.getPropertyType(obj, name);
|
|
try {
|
|
|
|
if (type.getPackage().getName().compareTo("java.util") == 0) {
|
|
type = null;
|
|
}
|
|
} catch (Exception e) {
|
|
}
|
|
Object value = this.manageValue(pMapBean.get(name), type);
|
|
try {
|
|
// PropertyUtils.setProperty(obj, name, value);
|
|
if (classType.compareTo("java.util.HashMap") == 0) {
|
|
((Map) obj).put(name, value);
|
|
} else {
|
|
if (value instanceof MorphDynaBean) {
|
|
value = this.manageBean((MorphDynaBean) value);
|
|
}
|
|
if (value instanceof Map) {
|
|
value = this.manageMapBean((Map) value);
|
|
}
|
|
BeanManager.setBeanAttributeValue(obj, name,
|
|
BeanManager.convertObject(value, BeanManager.getBeanGetterMethod(obj, name).getReturnType()));
|
|
}
|
|
} catch (Exception eadd) {
|
|
if (name.indexOf("transportBeanClass") > 0) {
|
|
String prop = name.replaceAll("_transportBeanClass", "");
|
|
Object objProp = this.prepareBean(prop, (String) value, pMapBean);
|
|
try {
|
|
// PropertyUtils.setProperty(obj, prop, objProp);
|
|
BeanManager.setBeanAttributeValue(obj, prop,
|
|
BeanManager.convertObject(objProp, BeanManager.getBeanGetterMethod(obj, prop).getReturnType()));
|
|
} catch (Exception e) {
|
|
try {
|
|
AbstractData dt = (AbstractData) obj;
|
|
dt.addAddtionalInfo(prop, objProp);
|
|
} catch (Exception e1) {
|
|
}
|
|
}
|
|
} else {
|
|
try {
|
|
if ((obj instanceof SaveRequest) && (value instanceof SaveBean)) {
|
|
((SaveRequest) obj).putSaveBean(((SaveBean) value).getBeanAlias(), value);
|
|
} else {
|
|
//JVC 22 octubre 2012 todo el if
|
|
if(obj instanceof AbstractDataTransport){
|
|
((AbstractDataTransport)obj).put(name, value);
|
|
}else{
|
|
AbstractData dt = (AbstractData) obj;
|
|
dt.addAddtionalInfo(name, value);
|
|
}
|
|
|
|
}
|
|
} catch (Exception e1) {
|
|
}
|
|
}
|
|
}
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
continue;
|
|
}
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
private Object prepareBean(String pPrefix, String pClass, Map pMapBean) throws ClassNotFoundException, InstantiationException,
|
|
IllegalAccessException {
|
|
Class c = Class.forName(pClass);
|
|
Object obj = c.newInstance();
|
|
Field[] fs = c.getDeclaredFields();
|
|
for (Field field : fs) {
|
|
try {
|
|
String name = field.getName();
|
|
if (name.compareTo("serialVersionUID") == 0) {
|
|
continue;
|
|
}
|
|
Object val = null;
|
|
try {
|
|
val = pMapBean.get(pPrefix + "_" + name);
|
|
} catch (Exception e1) {
|
|
continue;
|
|
}
|
|
BeanManager.setBeanAttributeValue(obj, name,
|
|
BeanManager.convertObject(val, BeanManager.getBeanGetterMethod(obj, name).getReturnType()));
|
|
} catch (Exception e) {
|
|
APPLogger.getLogger().debug(e);
|
|
continue;
|
|
}
|
|
}
|
|
return obj;
|
|
}
|
|
}
|