【Gson】【3】实例演习

【本文范围】：

本文并非JSON知识讲解资料，亦非GSON知识讲解资料，而是通过实例让开发人员了解通过Gson如何使Java对象和json对象进行相互转换。

【JSON参考资料】：

Json快速入门：Http://www.w3school.com.cn/json/index.asp

Json官网：http://www.json.org/

【GSON参考资料】：

Gson官网：http://code.Google.com/p/google-gson/

一、JSON基础知识：

1、Json概念：

Json全称javascript object notation(Javascript对象表示法)，是轻量级的文本数据交换格式，它独立于语言和平台，用来描述数据对象，具有自我描述性、容易理解等特性。

2、举例：

{“TeamName":"hr", "NewProject":true, "Leader":"wang", "Employee":[{"name":"li", "BelongTo":"train"}, {"name":"kpi", "BelongTo":"Security"}, {"name":"liu", "BelonTo":"service"}]}

这个Json对象描述了hr项目组。项目组名称为hr，是一个新项目，Leader是wang，有三个员工，分别为负责培训的li，负责kpi的zheng和负责服务的liu

3、Json语法

数据以健值对形式描述（如："TeamName":"hr"）；

数据以逗号分隔；

花括号保存对象（如{"Name":"li", "BelongTo":"train"}）；

方括号保存数组（如"csn":[20,21,22,23]）；

4、Json值：

数字（整数或浮点数）；

字符串（在双引号中）；

逻辑值（true或false）；

数组（在方括号中）；

对象（在花括号中）；

null

二、实例演习：

实例1：在查询告警窗口中对告警流水号为2012的记录做“清除”操作

【思路】：

假如清除操作的命令码为41，那么向服务端请求的JSON对象应该为{“cmdCode”:41, “csn”:2012}

【演示代码】：

1、定义AlarmClearCondition.java

public class AlarmClearCondition

{

private int cmdCode = 0;

private int csn = 0;

public void setCmdCode(int cmdCode)

{

thisNaNdCode = cmdCode;

}

public void setCsn(int csn)

{

this.csn= csn;

}

}

2、使用Gson把AlarmClearCondition对象转换为Json对象

AlarmClearConditioncondition = new AlarmClearCondition();

condition.setCmdCode(41);

condition.setCsn(2012);

Gson gson = newGson();

String jsonCond= gson.toJson(condition);

实例2：在查询告警窗口中对告警流水号为2012和2013的记录做“清除”操作

【思路】：

与实例1不同，这里的CSN有两个，意味着告警流水号CSN必须是一个数组，那么向服务端请求的JSON对象应该为{“cmdCode”:41, “csn”:[2012, 2013]}

【演示代码】：

1、改造AlarmClearCondition.java定义，使csn变成一个集合csnList

public class AlarmClearCondition

{

private int cmdCode = 0;

private List<Integer> csnList = newArrayList<Integer>();

public void setCmdCode(int cmdCode)

{

thisNaNdCode = cmdCode;

}

public void setCsn(int csn)

{

csnList.add(csn);

}

}

2、把AlarmClearCondition对象转换为Json对象

AlarmClearConditioncondition = new AlarmClearCondition();

condition.setCmdCode(41);

condition.setCsn(2012);

condition.setCsn(2013);

Gson gson = newGson();

String jsonCond= gson.toJson(condition);

实例3：若实例2中对流水号2012和2013的两条记录“清除”成功后，服务端返回的结果为{“errorCode”:0, “errORMsg”:“Clear alarmssuccessful!”, “clearedCsn”:[2012, 2013]}，则客户端如何把这个结果解析为Java对象？

【思路】：

1、直接用硬编码进行解析未尝不可，但代码不够优雅。

2、与生成Json对象一样定义一个Java类，剩余的转换工作由Gson协助完成。见演示代码。

【演示代码】：

1、定义AlarmClearResult类

public class AlarmClearResult

{

private int errorCode = 0;

privateString errorMsg = null;

private List<Integer> clearedCsn = new ArrayList<Integer>();

public int getErrorCode()

{

return errorCode;

}

public String getErrorMsg()

{

return errorMsg;

}

public List<Integer> getClearedCsn()

{

return clearedCsn;

}

}

2、把Json对象转换为AlarmClearResult对象

AlarmClearResult result =gson.fromJson(jsonObject, AlarmClearResult.class);

实例4：当前屏最后一条告警记录流水号为44531611，查询下一屏告警记录时与服务端约定请求条件为{“FieldName”:”logId”,”Operator”:”<”, “value”:44531611}，使用Gson把Java对象转换为此Json对象，但要求Java的属性字段定义为是“驼峰”风格。

【思路】：

1、不考虑属性字段定义“驼峰”风格问题，那只需要把FileName、Operator和value作为Java类的属性即可，见演示代码1。

2、为使Java属性字段定义和显示为不同的值，Gson提供了@SerializedName注释，见演示代码2.

【演示代码1】：

1、定义EndlessQuery类

public class EndlessQuery

{

private String FieldName = null;

private String Operator = null;

private int value = 0;

public void setFieldName(String filedName)

{

this.FieldName = fieldName;

}

public void setOperator(String operator)

{

this.Operator = operator;

}

public void setValue(int value)

{

this.value = value;

}

}

2、把AlarmClearResult转换为JSON对象

EndlessQueryqueryCond = new EndlessQuery();

queryCond.setFiledName(“logId”);

queryCond.setOperator(“<”);

queryCond.setValue(44531611);

Gson gson = newGson();

System.out.println(gson.toJson(queryCond));

【演示代码2】：

只修改EndlessQuery类的FileName和Operator两个字段即可，其余保持不变，如下：

public class EndlessQuery

{

@SerializedName(“FieldName”)

private String fieldName= null;

@SerializedName(“Operator”)

private String operator= null;

private int value = 0;

public void setFieldName(String filedName)

{

this.fieldName = fieldName;

}

public void setOperator(String operator)

{

this.operator = operator;

}

public void setValue(int value)

{

this.value = value;

}

}

实例5：列举一个稍微真实的场景，告警监控TOPN是指客户端向任意一个应用服务下发请求后，应用服务从各个数据服务中读取最新上报的TOPN条告警记录，然后再把获取的告警记录按条件进行重排序取TOPN条给客户端。

假如监控TOPN的命令码为22，每次监控40条最新的告警记录，在获取这40条最新的告警记录时使用的排序条件为“按网元发生时间”和“告警流水号”进行降序排序，其JSON对象为{"CmdCode":22, "Limit":40, "VersionID":0, "SortCond":[{"FieldName":"occurNeTime", "SortOrder":"desc","Priority":1},{"FieldName":"logId", "SortOrder":"desc", "Priority":6}]}，则客户端如何生成这个JSON对象？

【思路】：

1、直接拼凑字符串代码（不是本文的意图）。

2、定义属性字段为CmdCode、Limit、VersionID和SortCond的类，但SortCond与其它字段不同之处在于SortCond是一个集合，这个集合中对象类型必须能够描述出按“网元发生时间”和“流水号”进行排序。

【演示代码】：

1、定义排序SortConditionBean对象

public class SortConditionBean

{

@SerializedName("FieldName")

private String fieldName = null;

@SerializedName("SortOrder")

private String order = null;

@SerializedName("Priority")

private int priority = 0;

public void setFieldName(String fieldName)

{

this.fieldName = fieldName;

}

public void setOrder(String order)

{

this.order = order;

}

public void setPriority(int priority)

{

this.priority = priority;

}

}

2、定义监控TOPN对象MonitorTopnCond类

public class MonitorTopnCond

{

@SerializedName("CmdCode")

private int cmdCode = 0;

@SerializedName("VersionID")

private int versionID = 0;

@SerializedName("Limit")

private int limit = 0;

@SerializedName("SortCond")

private List<SortCondtionBean> sortCond = new ArrayList<SortConditionBean>():

public void setCmdCode(int cmdCode)

{

this.cmdCode = cmdCode;

}

public void setVersionID(int versionID)

{

this.versionID = versionID;

}

public void setLimit(int limit)

{

this.limit = limit;

}

public void setSortCond(SortConditionBean sortItem)

{

this.sortCond.add(sortItem);

}

}

3、测试方法：

SortConditionBean occuTime = new SortConditionBean();

occuTime.setFieldName("occurNeTime");

occuTime.setOrder("desc");

occuTime.setPriority(1);

SortConditionBean logID = new SortConditionBean();

logID.setFieldName("logId");

logID.setOrder("desc");

logID.setPriority(6);

MonitorTopnCond topnCond = new MonitorTopnCond();

topnCond.setCmdCode(22);

topnCond.setLimit(40);

topnCond.setVersionID(0);

topnCond.setSortCond(occuTime);

topnCond.setSortCond(logID);

Gson gson = new Gson();

System.out.println(gson.toJson(topnCond));

实例6：实例5中向应用服务下发监控TopN请求之后，应用服务从各个数据分区读取数据后，再重排序取了Top40条告警记录返回客户端，结果如下（为简单起见这里把40条告警记录改成1条）：

{

"ErrorMsg": "0",

"LastVersionId": 0,

"ResultCode":0,

"TotalNum":24006,

"records":

[

{

"Basic":["链路断连","BTS","NE=10009","NE=10009","Location=Test1, m_strPara=1","",-1,19],

"Paras":[0,0,0,0,0,19,0,0,0,0],

"intExt":[[0,0,0,0,0,0,0,0,0,0],[134, 13528,0,0,4,199,199]],

"strExt":[["","",""], ["","","","","127.0.0,1","",""]]

}

]

}

客户端如何解析这个Json对象呢？

【思路】：

仔细观察返回结果可发现，它由ErrorMsg、LastVersionId、ResultCode、TotalNum、records构成，所以可以定义一个Java类使其包含这五个属性字段。重要的一点records不同于ErrorMsg等属性字段，它又由有Basic、Paras、intExt和strExt构成。

【演示代码】：

1、定义告警记录对象AlarmRecord，对应record集合中的一个元素。

public class AlarmRecord

{

@SerializedName("Basic")

private List<Object> basicField = null;

@SerializedName("Paras")

private List<Integer> parasField = null;

@SerializedName("intExt")

private int[][] intExtField = null;

@SerializedName("strExt")

private String[][] strExtField = null;

public List<Object> getBasicField()

{

return basicField;

}

public List<Integer> getParasField()

{

return parasField;

}

public int[][] getIntExtField()

{

return intExtField;

}

public String[][] getStrExtField()

{

return strExtField;

}

}

2、定义结果响应对象AlarmResponseRecord

public class AlarmResponseRecord

{

@SerializedName("ResultCode")

private int errorCode = 0;

@SerializedName("ErrorMsg")

private String errorMessage = null;

@SerializedName("LastVersionId")

private int versionID = 0;

@SerializedName("TotalNum")

private int totalNum = 0;

private List<ALarmRecord> records = null;

public int getErrorCode()

{

return errorCode;

}

public String getErrorMessage()

{

return errorMessage;

}

public int getVersionID()

{

return versionID;

}

public int getTotalNum()

{

return totalNum;

}

public List<AlarmRecord> getRecords()

{

return records;

}

}

3、测试方法：

String result = "{'ErrorMsg':'ccq', 'LastVersionId':0, 'ResultCode':0, 'TotalNum':24006, 'records':[{'Basic':[0,'通讯系统',3,0,0,0,'链路断连'], 'Paras':[0,0,0,19,0,0], 'intExt':[[1,2,3,4,5],[6,7,8,9,11]], 'strExt':[['a','b','c','d'],['','','']]}]}";

Gson gson = new Gson();

AlarmResponseRecord almRecords = gson.fromJson(result, AlarmResponseRecord .class);

System.out.println(almRecords.getRecords());

实例7：告警监控TOPN请求的JSON对象为：{"CmdCode":22,"Limit":40,"VersionID":0,"SortCond":[{"FieldName":"occurNeTime", "SortOrder":"desc", "Priority":1},{"FieldName":"logId", "SortOrder":"desc","Priority":6}]}

告警无尽列表查询请求的JSON对象为{"CmdCode":21,"Limit":41,"SortCond":[{"FieldName":"occurNeTime", "SortOrder":"desc", "Priority":1},{"FieldName":"logId", "SortOrder":"desc","Priority":6}],"EndlessTableCond":[{"FieldName":"occurNeTime", "Operator":"=","value":[1355899366]},{"FieldName":"logId", "Operator":"<","value":[33394632]}]}

仔细观察会发现这两个请求的JSON对象结构非常类似，如何使用一个Java对象生成这两个Json对象呢？

【思路】：

很容易想到的是把相同的数据作为Java的属性字段（如CmdCode、Limit、SortCond），不同的数据作为子类属性字段（如EndlessTableCond、VersionID），使用Java的继承机制可实现。

【演示代码】：

1、定义排序对象SortConditionBean

public class SortConditionBean

{

@SerializedName("FieldName")

private String fieldName = null;

@SerializedName("SortOrder")

private String order = null;

@SerializedName("Priority")

private int priority = 0;

public void setFieldName(String fieldName)

{

this.fieldName = fieldName;

}

public void setOrder(String order)

{

this.order = order;

}

public void setPriority(int priority)

{

this.priority = priority;

}

}

2、定义无尽列表查询对象EndlessConditionBean

public class EndlessConditionBean

{

private String FieldName = null;

private String Operator = null;

private int value = 0;

public void setFieldName(String fieldName)

{

this.FieldName = fieldName;

}

public void setOperator(String operator)

{

this.Operator = operator;

}

public void setValue(int value)

{

this.value = value;

}

}

3、定义公共父类AlarmConditionBean对象

public class AlarmConditionBean

{

@SerializedName("CmdCode")

private int cmdCode = 0;

@SerializedName("Limit")

private int limit = 0;

@SerializedName("SortCond")

private List<SortConditionBean> sortCond = new ArrayList<SortConditionBean>();

public void setCmdCode(int cmdCode)

{

thisNaNdCode = cmdCode;

}

public void setLimit(int limit)

{

this.limit = limit;

}

public void setSortCond(SortConditionBean sortItem)

{

this.sortCond.add(sortItem);

}

}

5、定义监控AlarmMonitorBean类

public class AlarmMonitorBean extends AlarmConditionBean

{

@SerializedName("VersionID")

private int versionID = 0;

public void setVersionID(int versionID)

{

this.versionID = versionID;

}

}

6、定义查询AlarMQueryBean类

public class AlarmQueryBean extends AlarmConditionBean

{

@SerializedName("EndlessTableCond")

private List<EndlessConditionBean> queryCond = new ArrayList<EndlessConditionBean>();

public void setEndlessCond(EndlessConditionBean endlessItem)

{

queryCond.add(endlessItem);

}

}

7、测试代码

测试告警监控TOPN

SortConditionBean occuTimeSortItem = new SortConditionBean();

occuTimeSortItem.setFieldName("occurNeTime");

occuTimeSortItem.setOrder("desc");

occuTimeSortItem.setPriority(1);

SortConditionBean logIDSortItem = new SortConditionBean();

logIDSortItem.setFieldName("logId");

logIDSortItem.setOrder("desc");

logIDSortItem.setPriority(6);

AlarmMonitorBean monitorCond = new AlarmMonitorBean();

monitorCond.setCmdCode(22);

monitorCond.setLimit(40);

monitorCond.setVersionID(0);

monitorCond.sortSortCond(occuTimeSortItem);

monitorCond.sortSortCond(logIDSortItem);

Gson gson = new Gson();

System.out.println(gson.toJson(monitorCond));

测试告警无尽列表查询：

SortConditionBean occuTimeSortItem = new SortConditionBean();

occuTimeSortItem.setFieldName("occurNeTime");

occuTimeSortItem.setOrder("desc");

occuTimeSortItem.setPriority(1);

SortConditionBean logIDSortItem = new SortConditionBean();

logIDSortItem.setFieldName("logId");

logIDSortItem.setOrder("desc");

logIDSortItem.setPriority(6);

EndlessConditionBean occuTimeEndlessItem = new EndlessConditionBean();

occuTimeEndlessItem.setFieldName("occurNeTime");

occuTimeEndlessItem.setOperator("=");

occuTimeEndlessItem.setValue(1355899366);

EndlessConditionBean logIDEndlessItem = new EndlessConditionBean();

logIDEndlessItem.setFieldName("logId");

logIDEndlessItem.setOperator("<");

logIDEndlessItem.setValue(33394632);

AlarmQueryBean queryCond = new AlarmQueryBean();

queryCond.setCmdCode(21);

queryCond.setLimit(41);

queryCond.setSortCond(occuTimeSortItem);

queryCond.setSortCond(logIDSortItem);

queryCond.setEndlessCond(occuTimeEndlessItem);

queryCond.setEndlessCond(logIDEndlessItem);

Gson gson = new Gson();

System.out.println(gson.toJson(queryCond));

【备注】：

关于此例还有一种解决方式，即使用Gson的@Since注释，但这样会影响代码的易读性，不建议使用，有兴趣的读者可以了解一下Gson的api

实例8：服务端返回给客户端的数据只是一个数组，如[96301,0,1,"链路断连","BTS","NE=1009"]，此时客户端如何解析？

【思路】：

JSON对象在定义数据时明确指出数据是一个键值对，但并不表明Gson不能解析，因为这也是一个Json对象，这样做的目的主要是为了减少通讯传输量给带宽带来的拥挤。假如各字段的含义如下：

【演示代码】：

1、定义告警记录AlarmRecord类

final class AlarmSimpleRecord

{

private int logID = 0;

private int clearStatus = 0;

private int confirmStatus = 0;

private String alarmType = null;

private String neType = null;

private String neFDN = null;

public int getLogID()

{

return logID;

}

public void setLogID(int logID)

{

this.logID = logID;

}

public int getClearStatus()

{

return clearStatus;

}

public void setClearStatus(int clearStatus)

{

this.clearStatus = clearStatus;

}

public int getConfirmStatus()

{

return confirmStatus;

}

public void setConfirmStatus(int confirmStatus)

{

this.confirmStatus = confirmStatus;

}

public String getAlarmType()

{

return alarmType;

}

public void setAlarmType(String alarmType)

{

this.alarmType = alarmType;

}

public String getNeType()

{

return neType;

}

public void setNeType(String neType)

{

this.netype = neType;

}

public String getNeFDN()

{

return neFDN;

}

public void setNeFDN(String neFDN)

{

this.neFDN = neFDN;

}

}

2、解析演示

public class AlarmRecord

{

private static final int LOG_ID = 0;

private static final int CLEAR_STATUS = 1;

private static final int CONFIRM_STATUS = 2;

private static final int ALARM_TYPE = 3;

private static final int NE_TYPE = 4;

private static final int NE_FDN = 5;

public static void main(String[] args)

{

String result = "[96031, 0 ,1, '链路断连','BTS', 'NE=10009']";

Gson gson = new Gson();

JsonElement resultElement = gson.fromJson(result, JsonElement.class);

if(resultElement.isJsonNull())

{

// do nothing.

return;

}

AlarmSimpleRecord record = new AlarmSimpleRecord();

JsonArray elementArray = resultElement.getAsJsonArray();

record.setLogID(elementArray.get(LOG_ID).getAsInt());

record.setClearStatus(elementArray.get(CLEAR_STATUS).getAsInt());

record.setConfirmStatus(elementArray.get(CONFRIM_STATUS).getAsInt());

record.setAlarmType(elementArray.get(ALARM_TYPE).getAsString());

record.setNeType(elementArray.get(NE_TYPE).getAsString());

record.setNeFDN(elementArray.get(NE_FDN).getAsString());

System.out.println(record);

}

}