JSON各种操作类
public class JsonUtils{
/**
* 序列化为json字符串
* @param obj
* @return
*/
public static String convertRespData2JsonString(Object obj){
if(obj == null){
return null;
}
return JSON.toJSONString(obj);
}
/**
* 解析json为Map或Map[]，根据传入的是jsonString 或者是 jsonArrayString 来对应返回，深层转换
* @param jsonString
* @param isJsonArrayString
* @return 如果是jsonString,则返回Map<String,Object>类型，如果是jsonArrayString，则返回的是Map<String,Object>[]类型
*/
public static Object parseJson2Map(String jsonString,boolean isJsonArrayString){
if(StringUtils.isNotBlank(jsonString)){
jsonString = jsonString.replaceAll("\r\n", "");
if(isJsonArrayString){
JSONArray jsonArray = JSONArray.parseArray(jsonString);
return parseJson2MapArray(jsonArray);
}else{
JSONObject json = JSONObject.parseObject(jsonString);
return parseJson2Map(json);
}
}
return null;
}
/**
* 转换jsonObject为Map，深层转换
* @param jsonObject
* @return
*/
public static Map<String,Object> parseJson2Map(JSONObject jsonObject){
if(jsonObject != null && !jsonObject.isEmpty()){
Set<String> keySet = jsonObject.keySet();
HashMap<String,Object> map = new HashMap<String, Object>();
for(String key : keySet){
if(jsonObject.get(key) == null){
continue;
}else if(jsonObject.get(key) instanceof JSONObject){
map.put(key, parseJson2Map(jsonObject.getJSONObject(key)));
}else if(jsonObject.get(key) instanceof JSONArray){
map.put(key, parseJson2MapArray(jsonObject.getJSONArray(key)));
}else if(jsonObject.get(key) instanceof String){
if(StringUtils.isBlank(jsonObject.getString(key))){
map.put(key, null);
}else{
map.put(key, jsonObject.getString(key));
}
}else{
map.put(key, jsonObject.get(key));
}
}
return map;
}
return null;
}
/**
* 转换dataObjs为Map[]，不深层转换，只转换第一层，不转换1：1、1：n
* @param dataObjs
* @return
*/
@SuppressWarnings("unchecked")
public static Map<String,Object>[] convertDataObjs2HashMapArray(DataObject[] dataObjs,String[] excludeProperties){
if(dataObjs == null || dataObjs.length == 0){
return null;
}
List<String> excludeProList = excludeProperties == null || excludeProperties.length == 0 ? null : Arrays.asList(excludeProperties);
int size = dataObjs.length;
if(size == 0){
return null;
}else{
List<Map<String,Object>> mapList = new ArrayList<Map<String,Object>>();
HashMap<String,Object> map;
for(int i = 0; i < size; i++){
DataObject data = dataObjs[i];
List<Property> instanceProperties = data.getInstanceProperties();
map = new HashMap<String,Object>();
for(Property pro : instanceProperties){
boolean containment = pro.isContainment();
boolean openContent = pro.isOpenContent();
boolean many = pro.isMany();
if(pro != null && (!containment || openContent) && !many && pro.getName() != null){
if(excludeProList != null && excludeProList.contains(pro.getName())){
continue;
}
map.put(pro.getName(),data.get(pro));
}
}
if(map != null && map.size() > 0){
mapList.add(map);
}
}
return (Map<String, Object>[]) mapList.toArray(new HashMap[size]);
}
}
/**
* 转换jsonArray为Map[]，深层转换
* @param jsonArray
* @return
*/
@SuppressWarnings("unchecked")
public static Map<String,Object>[] parseJson2MapArray(JSONArray jsonArray){
int size = jsonArray.size();
if(size == 0){
return null;
}else{
List<Map<String,Object>> mapList = new ArrayList<Map<String,Object>>();
for(int i = 0; i < jsonArray.size(); i++){
JSONObject json = jsonArray.getJSONObject(i);
Map<String, Object> map = parseJson2Map(json);
if(map != null){
mapList.add(map);
}
}
return (Map<String, Object>[]) mapList.toArray(new HashMap[size]);
}
}
/**
* 从map中取key对应的value设置到DataObject，p为dataObject的基础属性，map中的 key为p的name
* @param p
* @param data
* @param map
*/
private static void setDataByType(Property p,DataObject data,Map<String,Object> map){
if(StringUtils.isBlank(p.getName()) || map.get(p.getName()) == null ||
map.get(p.getName()).toString() == null || StringUtils.isBlank(map.get(p.getName()).toString())){
return;
}
Object sdoValue = DataUtil.toSDOValue(p.getType(), map.get(p.getName()));
data.set(p,sdoValue);
}
/**
* 转换Map或Map[]为DataObject或DataObject[]，深层转换，不支持commonj.sdo.DataObject、com.primeton.das.datatype.AnyType等无映射关系的实体
* 不设置Map或map[]中非DataObject的实体属性与值
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
public static Object convertMap2DataObject(Object map,String entityName){
if(StringUtils.isBlank(entityName)){
return null;
}
if("commonj.sdo.DataObject".equals(entityName)){
throw new EOSRuntimeException("不支持的实体:" + entityName);
}
DataObject dataObj = null;
if(map == null) return null;
if(map instanceof Map[]){
Map[] dataMaps = (Map[]) map;
if(dataMaps != null && dataMaps.length > 0){
List<DataObject> dataList = new ArrayList<DataObject>();
for(int i = 0;i < dataMaps.length; i++){
dataObj = DataObjectUtil.createDataObject(entityName);
dataObj = convert2DataObjectByMap(dataMaps[i],dataObj);
dataList.add(dataObj);
}
DataObject[] dataobjs = dataList.toArray(new DataObject[dataList.size()]);
return dataobjs;
}
}else if(map instanceof Map){
Map<String,Object> dataMap = (Map<String,Object>)map;
dataObj = DataObjectUtil.createDataObject(entityName);
dataObj = convert2DataObjectByMap(dataMap,dataObj);
return dataObj;
}
return null;
}
/**
* 转换Map为DataObject，深层转换，不支持commonj.sdo.DataObject、com.primeton.das.datatype.AnyType等无映射关系的实体，
* 不设置Map中非DataObject的实体属性与值
* @param map
* @param data
* @return
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
private static DataObject convert2DataObjectByMap(Map<String,Object> map, DataObject data) {
List<Property> instanceProperties = data.getInstanceProperties();
DataObject[] dataObjs = null;
for (Property p : instanceProperties) {
if (p.isContainment() && p.isMany()) {
//1 对 n
Map[] maps = (Map[]) map.get(p.getName());
if(maps == null || maps.length == 0){
continue;
}
dataObjs = new DataObject[maps.length];
Type type = p.getType();
String subEntityName = type.getURI()+"."+type.getName();
for(int i = 0;i < maps.length; i++){
DataObject inlineDataObj = DataObjectUtil.createDataObject(subEntityName);
Map<String,Object> inlineMap = maps[i];
dataObjs[i] = convert2DataObjectByMap(inlineMap,inlineDataObj);
}
data.set(p, dataObjs);
}else{
if(p.isContainment()){
//有关联实体1对1
String subOne2OneEntityName = p.getType().getURI() + "." + p.getType().getName();
DataObject subOne2OneDataObj = DataObjectUtil.createDataObject(subOne2OneEntityName);
subOne2OneDataObj = convert2DataObjectByMap((Map<String, Object>) map.get(p.getName()),subOne2OneDataObj);
data.set(p, subOne2OneDataObj);
}else{
if(StringUtils.isNotBlank(p.getName())){
setDataByType(p,data,map);
}
}
}
}
return data;
}
/**
* 转换Map或Map[]为DataObject或DataObject[](类型：commonj.sdo.DataObject、com.primeton.das.datatype.AnyType)，深层转换
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
public static Object convertMap2AnyTypeDataObject(Object map){
DataObject dataObj = null;
if(map == null) return null;
if(map instanceof Map[]){
Map[] dataMaps = (Map[]) map;
if(dataMaps != null && dataMaps.length > 0){
List<DataObject> dataList = new ArrayList<DataObject>();
for(int i = 0;i < dataMaps.length; i++){
dataObj = DataObjectUtil.createDataObject("com.primeton.das.datatype.AnyType");
dataObj = convert2AnyTypeDataObjectByMap(dataMaps[i],dataObj);
dataList.add(dataObj);
}
DataObject[] dataobjs = dataList.toArray(new DataObject[dataList.size()]);
return dataobjs;
}
}else if(map instanceof Map){
Map<String,Object> dataMap = (Map<String,Object>)map;
dataObj = DataObjectUtil.createDataObject("com.primeton.das.datatype.AnyType");
dataObj = convert2AnyTypeDataObjectByMap(dataMap,dataObj);
return dataObj;
}
return null;
}
/**
* 转换Map或Map[]为DataObject或DataObject[](类型：commonj.sdo.DataObject、com.primeton.das.datatype.AnyType)，深层转换
* @param map
* @param dataObj
* @return
*/
@SuppressWarnings("rawtypes")
private static DataObject convert2AnyTypeDataObjectByMap(Map map,
DataObject dataObj) {
if(map == null || map.isEmpty()){
return null;
}
@SuppressWarnings("unchecked")
Set<String> keySet = map.keySet();
for(String key : keySet){
if(StringUtils.isBlank(key)){
continue;
}
Object object = map.get(key);
if(object != null && object instanceof Map[]){
Map[] array = (Map[])object;
DataObject[] inlineDataObjects = new DataObject[array.length];
for(int i = 0,j = array.length; i < j; i++){
DataObject inlineData = DataObjectUtil.createDataObject("com.primeton.das.datatype.AnyType");
inlineDataObjects[i] = convert2AnyTypeDataObjectByMap(array[i],inlineData);
}
dataObj.set(key, inlineDataObjects);
}else if(object != null && object instanceof Map){
DataObject inlineData = DataObjectUtil.createDataObject("com.primeton.das.datatype.AnyType");
dataObj.set(key, convert2AnyTypeDataObjectByMap((Map)object,inlineData));
}else{
dataObj.set(key, object);
}
}
return dataObj;
}
/**
* 解析json为Map或Map[]，根据传入的是jsonString 或者是 jsonArrayString 来对应返回，深层转换
* @param jsonString
* @param isJsonArrayString
* @return 如果是jsonString,则返回Map<String,Object>类型，如果是jsonArrayString，则返回的是Map<String,Object>[]类型
*/
public static Object parseJsonString2DataObject(String jsonString,String entityName){
if(StringUtils.isNotBlank(jsonString)){
jsonString = jsonString.replaceAll("\r\n", "");
Object parse = JSON.parse(jsonString);
Object dataObj = convertJson2DataObject(parse,entityName);
return dataObj;
}
return null;
}
/**
* 转换jsonString或jsonArray为DataObject或DataObject[]，深层转换，不支持commonj.sdo.DataObject、com.primeton.das.datatype.AnyType等无映射关系的实体
* 不设置Map或map[]中非DataObject的实体属性与值
*/
public static Object convertJson2DataObject(Object json,String entityName){
if(StringUtils.isBlank(entityName)){
return null;
}
if("commonj.sdo.DataObject".equals(entityName) || "com.primeton.das.datatype.AnyType".equals(entityName)){
throw new EOSRuntimeException("不支持的实体:" + entityName);
}
DataObject dataObj = null;
if(json == null) return null;
if(json instanceof JSONArray){
JSONArray jsonArray = (JSONArray) json;
if(jsonArray != null && jsonArray.size() > 0){
List<DataObject> dataList = new ArrayList<DataObject>();
for(int i = 0;i < jsonArray.size(); i++){
dataObj = DataObjectUtil.createDataObject(entityName);
dataObj = convert2DataObjectByJSON(jsonArray.getJSONObject(i),dataObj);
dataList.add(dataObj);
}
DataObject[] dataobjs = dataList.toArray(new DataObject[dataList.size()]);
return dataobjs;
}
}else if(json instanceof JSONObject){
JSONObject jsonObj = (JSONObject)json;
dataObj = DataObjectUtil.createDataObject(entityName);
dataObj = convert2DataObjectByJSON(jsonObj,dataObj);
return dataObj;
}
return null;
}
/**
* 转换json为DataObject，深层转换，不支持commonj.sdo.DataObject、com.primeton.das.datatype.AnyType等无映射关系的实体，
* 不设置json中非DataObject的实体属性与值
* @param json
* @param data
* @return
*/
@SuppressWarnings("unchecked")
private static DataObject convert2DataObjectByJSON(JSONObject json, DataObject data) {
List<Property> instanceProperties = data.getInstanceProperties();
DataObject[] dataObjs = null;
for (Property p : instanceProperties) {
if (p.isContainment() && p.isMany()) {
//1 对 n
JSONArray jsonArray = (JSONArray) json.getJSONArray(p.getName());
if(jsonArray == null || jsonArray.size() == 0){
continue;
}
dataObjs = new DataObject[jsonArray.size()];
Type type = p.getType();
String subEntityName = type.getURI()+"."+type.getName();
for(int i = 0;i < jsonArray.size(); i++){
DataObject inlineDataObj = DataObjectUtil.createDataObject(subEntityName);
JSONObject inlineJsonObj = jsonArray.getJSONObject(i);
dataObjs[i] = convert2DataObjectByJSON(inlineJsonObj,inlineDataObj);
}
data.set(p, dataObjs);
}else{
if(p.isContainment()){
//有关联实体1对1
String subOne2OneEntityName = p.getType().getURI() + "." + p.getType().getName();
DataObject subOne2OneDataObj = DataObjectUtil.createDataObject(subOne2OneEntityName);
subOne2OneDataObj = convert2DataObjectByJSON((JSONObject) json.get(p.getName()),subOne2OneDataObj);
data.set(p, subOne2OneDataObj);
}else{
if(StringUtils.isNotBlank(p.getName())){
setDataByType(p,data,json);
}
}
}
}
return data;
}
/**
* 解析json为Map或Map[]，根据传入的是jsonString 或者是 jsonArrayString 来对应返回，深层转换
* @param jsonString
* @param isJsonArrayString
* @return 如果是jsonString,则返回Map<String,Object>类型，如果是jsonArrayString，则返回的是Map<String,Object>[]类型
*/
@Bizlet
public static Object parseJsonString2AnyTypeDataObject(String jsonString){
if(StringUtils.isNotBlank(jsonString)){
jsonString = jsonString.replaceAll("\r\n", "");
Object parse = JSON.parse(jsonString);
Object dataObj = convertJson2AnyTypeDataObject(parse);
return dataObj;
}
return null;
}
/**
* 转换json为DataObject或dataObject[](com.primeton.das.datatype.AnyType)，深层转换，json的所有key与value都设置到dataObject中
*/
public static Object convertJson2AnyTypeDataObject(Object json){
DataObject dataObj = null;
if(json == null) return null;
if(json instanceof JSONArray){
JSONArray jsonArray = (JSONArray) json;
if(jsonArray != null && jsonArray.size() > 0){
List<DataObject> dataList = new ArrayList<DataObject>();
for(int i = 0;i < jsonArray.size(); i++){
dataObj = DataObjectUtil.createDataObject("com.primeton.das.datatype.AnyType");
dataObj = convertJson2AnyTypeDataObject(jsonArray.getJSONObject(i),dataObj);
dataList.add(dataObj);
}
DataObject[] dataobjs = dataList.toArray(new DataObject[dataList.size()]);
return dataobjs;
}
}else if(json instanceof JSONObject){
JSONObject jsonObj = (JSONObject)json;
dataObj = DataObjectUtil.createDataObject("com.primeton.das.datatype.AnyType");
dataObj = convertJson2AnyTypeDataObject(jsonObj,dataObj);
return dataObj;
}
return null;
}
/**
* 转换json为DataObject(com.primeton.das.datatype.AnyType)，深层转换，json的所有key与value都设置到dataObject中
* @param json
* @return
*/
private static DataObject convertJson2AnyTypeDataObject(JSONObject json,DataObject data){
if(json == null || json.isEmpty()){
return null;
}
Set<String> keySet = json.keySet();
for(String key : keySet){
if(StringUtils.isBlank(key)){
continue;
}
Object object = json.get(key);
if(object != null && object instanceof JSONArray){
JSONArray array = (JSONArray)object;
DataObject[] inlineDataObjects = new DataObject[array.size()];
for(int i = 0,j = array.size(); i < j; i++){
DataObject inlineData = DataObjectUtil.createDataObject("com.primeton.das.datatype.AnyType");
inlineDataObjects[i] = convertJson2AnyTypeDataObject(array.getJSONObject(i),inlineData);
}
data.set(key, inlineDataObjects);
}else if(object != null && object instanceof JSONObject){
DataObject inlineData = DataObjectUtil.createDataObject("com.primeton.das.datatype.AnyType");
data.set(key, convertJson2AnyTypeDataObject((JSONObject)object,inlineData));
}else{
data.set(key, object);
}
}
return data;
}
public static String convertDataObjectToJsonString(DataObject dataObject) {
DataObject[] dataObjects = new DataObject[]{dataObject};
String jsonString = convertDataObjectsToJsonString(dataObjects);
jsonString = jsonString.substring(1, jsonString.length() - 1);
return jsonString;
}
/**
*转换DataObject数组返回Json字符串
* @param dataObject
* @author linfeng
*/
public static String convertDataObjectsToJsonString(DataObject[] dataObjects) {
Map<String,DataObject[]> root = new HashMap<String,DataObject[]>();
root.put("data", dataObjects);
StringWriter stringWriter = new StringWriter();
JSONWriter jsonWriter = new JSONWriter(stringWriter);
try {
ExtendedXMLSerializer serializer = new ExtendedXMLSerializer();
SerializeOption operation = new SerializeOption();
operation.setCreateOuterCollectionNode(true);
serializer.setOption(operation);
IMarshallingNode node = serializer.marshallToNode(root, "root");
jsonWriter.object();
List<IMarshallingNode> children = node.getChildren();
for (IMarshallingNode child : children) {
write(child, jsonWriter);
}
jsonWriter.endObject();
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException(e.getMessage());
}
String jsonString = stringWriter.toString();
jsonString = jsonString.substring(8, jsonString.length() - 1);
return jsonString;
}
private static void write(IMarshallingNode node, JSONWriter writer)
throws JSONException {
int type = getNodeType(node);
List<IMarshallingNode> children = null;
switch (type) {
case 1:
Object nodeValue = node.getValue();
boolean writeValue = false;
if ((nodeValue == null) || (Boolean.class == nodeValue.getClass())
|| (Number.class.isAssignableFrom(nodeValue.getClass()))) {
writeValue = true;
}
if (node.isEntry()) {
writer.value(writeValue == true ? nodeValue : node.getText());
} else
writer.key(node.getName()).value(
writeValue == true ? nodeValue : node.getText());
break;
case 2:
if (!node.isEntry()) {
writer.key(node.getName());
}
writer.array();
children = node.getChildren();
for (IMarshallingNode child : children) {
write(child, writer);
}
writer.endArray();
break;
case 3:
if (!node.isEntry()) {
writer.key(node.getName());
}
writer.object();
children = node.getChildren();
for (IMarshallingNode child : children) {
write(child, writer);
}
writer.endObject();
break;
case 4:
String xml = com.eos.system.utility.XmlUtil.node2String(
(Node) node.getValue(), false, false, "UTF-8");
if (node.isEntry())
writer.value(xml);
else {
writer.key(node.getName()).value(xml);
}
break;
case -1:
case 0:
break;
}
}
@SuppressWarnings("rawtypes")
private static int getNodeType(IMarshallingNode node) {
if (!node.isSet()) {
return -1;
}
if (node.isXml()) {
return 4;
}
if (node.getChildren().size() <= 0) {
if (node.getText() != null)
return 1;
if ("null".equals(node.getAttribute("__isNullOrEmpty"))) {
return 1;
}
if ("empty".equals(node.getAttribute("__isNullOrEmpty"))) {
String type = node.getAttribute("__type");
if (type == null)
return 3;
try {
Class clazz = Class
.forName(type.substring("java:".length()));
if ((clazz != null)
&& ((clazz.isArray()) || (Collection.class
.isAssignableFrom(clazz)))) {
return 2;
}
return 3;
} catch (ClassNotFoundException e) {
}
}
} else if (((IMarshallingNode) node.getChildren().get(0)).isEntry()) {
return 2;
}
return 3;
}
}
扫一扫
138
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
