本文目录一览：
- 1、java中使用gson解析json的问题
- 2、如何统一解析JSON数据，使用Gson结合泛型类
- 3、如何通过gson解析存储的json数组字符串
- 4、Java解析json数据
- 5、如何用Gson解析复杂的Json数据
- 6、怎样使用Gson 解析 json字符串
java中使用gson解析json的问题
首先我不明白所报的错是什么错，如果是跟ORM框架有关的那就是懒加载造成的。
一般来说对象转json不那么容易抛错的，只有json转对象出错较高，你要注意的是你的对象属性是否有标准的getter和setter方法。
如何统一解析JSON数据，使用Gson结合泛型类
public class JsonRootBean {
private String code;
private Data data;
private ListString error;
private String msg;
public void setCode(String code) {
this.code = code;
}
public String getCode() {
return code;
}
public void setData(Data data) {
this.data = data;
}
public Data getData() {
return data;
}
public void setError(ListString error) {
this.error = error;
}
public ListString getError() {
return error;
}
public void setMsg(String msg) {
this.msg = msg;
}
public String getMsg() {
return msg;
}
}
我们知道，所有的接口返回的数据格式都是一样的，就拿上面的返回结果来说吧，返回的Json字符串中只是"data": {"code":"0002","resultData":null,"resultMsg":"用户Token过期,请重新登入"｝，这个
data中的“resultData”中的返回数据不一样，其他数据格式都是一样的，所以我们这里使用泛型Java实体类，一次解析全部搞定！
把上面的Java实体类中的 Data成员变量改为：
[html] view plain copy
public class JsonRootBeanT {
private DataT data;
public DataT getData() {
return data;
}
public void setData(DataT data) {
this.data = data;
}
}
而其中的Data类为：
[html] view plain copy
public class DataT {
private String code;
private T resultData;
private String resultMsg;
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
public T getResultData() {
return resultData;
}
public void setResultData(T resultData) {
this.resultData = resultData;
}
public String getResultMsg() {
return resultMsg;
}
public void setResultMsg(String resultMsg) {
this.resultMsg = resultMsg;
}
}
那我们在解析的时候，对返回的Json串，作如下处理：
1、如果返回的字符串resultData直接为 ｛“对象”｝，处理如下：
Type jsonType = new TypeTokenJsonRootBeanTripResultData() {}.getType();
JsonRootBeanTripResultData rootBean = new Gson().fromJson(jsonStr, jsonType);
然后根据 rootBean的get方法，依次获取相应的data值 ，然后根据泛型 T 为TripResultData的具体实体类来获取具体的数据；
2、如果返回的字符串resultData直接为数组 [｛“对象”｝]，处理如下：
Type jsonType = new TypeTokenJsonRootBeanTripResultData() {}.getType();
JsonRootBeanListTripResultData rootBean = new Gson().fromJson(jsonStr, jsonType); 其实实体类泛型写在列表里面 ListT;
其实这个时候，所有的数据都已经解析到这个 rootBean里面了，你就可以自己根据自己写的的方法获取。
如何通过gson解析存储的json数组字符串
引入gson-1.4.jar，（挺蛋疼的，不想自己研究这玩意，寻思网上直接找现成的Demo，结果没有我想要的东西）
Gson中重要的几个核心类：
Gson、JsonParser、JsonObject、JsonArray。
下面演示这两个类之间的转换过程：
import Java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
public class GsonTest {
public static void main(String[] args) {
Map map = new HashMap();
map.put("name", "nam1");
map.put("age", "12");
List list = new ArrayList();
list.add("name");
list.add("123");
list.add(map);
//json格式的字符串
String str = "[{'name':'kevin','age':25},{'name':'cissy','age':24}]";
//创建一个Gson对象
Gson gson = new Gson();
//把java对象转换成Json字符串。
String jsonStr = gson.toJson(map);
System.out.println(jsonStr);
//把集合对象转换成Json字符串
jsonStr = gson.toJson(list);
System.out.println(jsonStr);
//创建一个JsonParser
JsonParser parser = new JsonParser();
//通过JsonParser对象可以把json格式的字符串解析成一个JsonElement对象
JsonElement el = parser.parse(str);
//把JsonElement对象转换成JsonObject
JsonObject jsonObj = null;
if(el.isJsonObject()){
jsonObj = el.getAsJsonObject();
}
//把JsonElement对象转换成JsonArray
JsonArray jsonArray = null;
if(el.isJsonArray()){
jsonArray = el.getAsJsonArray();
}
//遍历JsonArray对象
MyField field = null;
Iterator it = jsonArray.iterator();
while(it.hasNext()){
JsonElement e = (JsonElement)it.next();
//JsonElement转换为JavaBean对象
field = gson.fromJson(e, MyField.class);
System.out.println(field.getName()+" === "+field.getAge());
}
}
}
class MyField {
private String name;
private Integer age;
public MyField() {
}
public MyField(String name, Integer age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}
Java解析json数据
一、 JSON （JavaScript Object Notation）一种简单的数据格式，比xml更轻巧。
Json建构于两种结构：
1、“名称/值”对的集合（A collection of name/value pairs）。不同的语言中，它被理解为对象（object），纪录（record），结构（struct），字典（dictionary），哈希表（hash table），有键列表（keyed list），或者关联数组 （associative array）。 如：
{
“name”:”jackson”,
“age”:100
}
2、值的有序列表（An ordered list of values）。在大部分语言中，它被理解为数组（array）如：
{
“students”:
[
{“name”:”jackson”,“age”:100},
{“name”:”michael”,”age”:51}
]
}
二、java解析JSON步骤
A、服务器端将数据转换成json字符串
首先、服务器端项目要导入json的jar包和json所依赖的jar包至builtPath路径下（这些可以到JSON-lib官网下载：）
然后将数据转为json字符串，核心函数是：
public static String createJsonString(String key, Object value)
{
JSONObject jsonObject = new JSONObject();
jsonObject.put(key, value);
return jsonObject.toString();
}
B、客户端将json字符串转换为相应的javaBean
1、客户端获取json字符串（因为android项目中已经集成了json的jar包所以这里无需导入）
public class HttpUtil
{
public static String getJsonContent(String urlStr)
{
try
{// 获取HttpURLConnection连接对象
URL url = new URL(urlStr);
HttpURLConnection httpConn = (HttpURLConnection) url
.openConnection();
// 设置连接属性
httpConn.setConnectTimeout(3000);
httpConn.setDoInput(true);
httpConn.setRequestMethod("GET");
// 获取相应码
int respCode = httpConn.getResponseCode();
if (respCode == 200)
{
return ConvertStream2Json(httpConn.getInputStream());
}
}
catch (MalformedURLException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
catch (IOException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
return "";
}
private static String ConvertStream2Json(InputStream inputStream)
{
String jsonStr = "";
// ByteArrayOutputStream相当于内存输出流
ByteArrayOutputStream out = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
int len = 0;
// 将输入流转移到内存输出流中
try
{
while ((len = inputStream.read(buffer, 0, buffer.length)) != -1)
{
out.write(buffer, 0, len);
}
// 将内存流转换为字符串
jsonStr = new String(out.toByteArray());
}
catch (IOException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
return jsonStr;
}
}
2、获取javaBean
public static Person getPerson(String jsonStr)
{
Person person = new Person();
try
{// 将json字符串转换为json对象
JSONObject jsonObj = new JSONObject(jsonStr);
// 得到指定json key对象的value对象
JSONObject personObj = jsonObj.getJSONObject("person");
// 获取之对象的所有属性
person.setId(personObj.getInt("id"));
person.setName(personObj.getString("name"));
person.setAddress(personObj.getString("address"));
}
catch (JSONException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
return person;
}
public static ListPerson getPersons(String jsonStr)
{
ListPerson list = new ArrayListPerson();
JSONObject jsonObj;
try
{// 将json字符串转换为json对象
jsonObj = new JSONObject(jsonStr);
// 得到指定json key对象的value对象
JSONArray personList = jsonObj.getJSONArray("persons");
// 遍历jsonArray
for (int i = 0; i personList.length(); i++)
{
// 获取每一个json对象
JSONObject jsonItem = personList.getJSONObject(i);
// 获取每一个json对象的值
Person person = new Person();
person.setId(jsonItem.getInt("id"));
person.setName(jsonItem.getString("name"));
person.setAddress(jsonItem.getString("address"));
list.add(person);
}
}
catch (JSONException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
return list;
}
如何用Gson解析复杂的Json数据
你先定义类，然后使用Gson的fromJson方法转换成类。
下面是我的代码：
public class showapi_res_body {
private cityInfo cityInfo = new cityInfo();
private f1 f1 = new f1();
@Override
public String toString() {
return "showapi_res_body [cityInfo=" + cityInfo.toString() + ", f1=" + f1.toString() + "]";
}
}
public class day_weather_pic {
private int night_air_temperature = 19;
private String night_weather = "多云";
@Override
public String toString() {
return "day_weather_pic [night_air_temperature=" + night_air_temperature + ", night_weather=" + night_weather
+ "]";
}
}
public class f1 {
private String day="20150906";
private int day_air_temperature=3;
private String day_weather= "晴";
private day_weather_pic day_weather_pic = new day_weather_pic();
@Override
public String toString() {
return "f1 [day=" + day + ", day_air_temperature=" + day_air_temperature + ", day_weather=" + day_weather
+ ", day_weather_pic=" + day_weather_pic.toString() + "]";
}
}
public class cityInfo {
private String c2 ="lanzhou";
private String c3 ="兰州";
@Override
public String toString() {
return "cityInfo [c2=" + c2 + ", c3=" + c3 + "]";
}
}
public class showapi {
private int showapi_res_code = 0;
private String showapi_res_error = "";
private showapi_res_body showapi_res_body = new showapi_res_body();
@Override
public String toString() {
return "showapi [showapi_res_code=" + showapi_res_code + ", showapi_res_error=" + showapi_res_error
+ ", showapi_res_body=" + showapi_res_body.toString() + "]";
}
}
public class test {
public static void main(String[] args) {
showapi anObject = new showapi();
Gson gson = new Gson();
String json = gson.toJson(anObject);
System.out.println(json.toString());
showapi a = gson.fromJson(json, showapi.class);
System.out.println(a.toString());
}
}
怎样使用Gson 解析 json字符串
Gson是谷歌推出的解析json数据以及将对象转换成json数据的一个开源框架. 现在json因其易读性和高效率而被广泛的使用着. 相对于java以及其它json的解析框架,Gson非常的好用. 简单来讲就是根据json的数据结构定义出相应的javabean
