GSON解析json中存在不确定实体类

最新推荐文章于 2025-06-13 15:12:07 发布
原创 最新推荐文章于 2025-06-13 15:12:07 发布 · 5.2k 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#gson #json #解析 #不确定实体类 #Java

本文介绍了解析包含不同实体类的JSON数据的方法，通过使用泛型和反射工厂模式解决了类型不确定的问题，并提供了完整的Java代码示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

这几天遇到个解析json的问题，返回的json数据中包含不同的实体类，实体类的键值是确定的但是类型是不确定的。（尴尬描述可能不对，下面给出json例子）

json数据例子如下：
String dataA = "{a:1, b:'Hello,world!', c:true, d:{aa:1}}";
String dataB = "{a:2, b:'Hello,world!', c:true, d:{ba:1, bb:'Hello word!'}}";
String dataC = "{a:3, b:'Hello,world!', c:true, d:{ca:1, cb:'Hello,:world!', cc:true}}";

网上找了很久，首先找到定义d为泛型，然后用JSONObject  jsond = new JSONObject(String arg0)的方法得到d的json数据，最后用D d =  gson.fromJson( jsond.toString(), D.class)解析出具体的实体类。下面看一下具体的实现。

Entity.java

public class Entity {
	private int a;
	private String b;
	private boolean c;
	private Object d;
	public int getA() {
		return a;
	}
	public void setA(int a) {
		this.a = a;
	}
	public String getB() {
		return b;
	}
	public void setB(String b) {
		this.b = b;
	}
	public boolean isC() {
		return c;
	}
	public void setC(boolean c) {
		this.c = c;
	}
	public Object getD() {
		return d;
	}
	public void setD(Object d) {
		this.d = d;
	}
	@Override
	public String toString() {
		return "Entity [a=" + a + ", b=" + b + ", c=" + c + ", d=" + d + "]";
	}
}
DA.java

public class DA {
	private int aa;
	public int getAa() {
		return aa;
	}
	public void setAa(int aa) {
		this.aa = aa;
	}
	@Override
	public String toString() {
		return "DA [aa=" + aa + "]";
	}
}

DB.java

public class DB {
	private int ba;
	private String bb;
	public int getBa() {
		return ba;
	}
	public void setBa(int ba) {
		this.ba = ba;
	}
	public String getBb() {
		return bb;
	}
	public void setBb(String bb) {
		this.bb = bb;
	}
	@Override
	public String toString() {
		return "DB [ba=" + ba + ", bb=" + bb + "]";
	}
}

DC.java

public class DC {
	private int ca;
	private String cb;
	private boolean cc;
	public DC(int ca, String cb, boolean cc) {
		super();
		this.ca = ca;
		this.cb = cb;
		this.cc = cc;
	}
	public int getCa() {
		return ca;
	}
	public void setCa(int ca) {
		this.ca = ca;
	}
	public String getCb() {
		return cb;
	}
	public void setCb(String cb) {
		this.cb = cb;
	}
	public boolean isCc() {
		return cc;
	}
	public void setCc(boolean cc) {
		this.cc = cc;
	}
	@Override
	public String toString() {
		return "DC [ca=" + ca + ", cb=" + cb + ", cc=" + cc + "]";
	}
}
jsontest.java

import com.google.gson.Gson;
import com.mathworks.toolbox.javabuilder.external.org.json.JSONObject;

public class jsontest {
	public static void main(String[] args) {
		String dataA = "{a:1, b:'Hello,world!', c:true, d:{aa:1}}";
		String dataB = "{a:2, b:'Hello,world!', c:true, d:{ba:1, bb:'Hello word!'}}";
		String dataC = "{a:3, b:'Hello,world!', c:true, d:{ca:1, cb:'Hello,:world!', cc:true}}";
	    Gson gson = new Gson();  
	    Entity ea = gson.fromJson(dataA, Entity.class);
	    Entity eb = gson.fromJson(dataB, Entity.class);
	    Entity ec = gson.fromJson(dataC, Entity.class);

	    System.out.println("ea ="+ea.toString());
	    System.out.println("eb ="+eb.toString());
	    System.out.println("ec ="+ec.toString());

	    ea = gson.fromJson(dataA, Entity.class);
	    eb = gson.fromJson(dataB, Entity.class);
	    ec = gson.fromJson(dataC, Entity.class);
	    if(ea.getA()==1){
		    System.out.println("ea.getD() ="+ea.getD().toString());
	    	try {
				JSONObject d = new JSONObject(ea.getD().toString());
			    System.out.println("d ="+d.toString());
		    	DA da =  gson.fromJson(d.toString(), DA.class);
			    System.out.println("da ="+da.toString());
			} catch (Exception e) {
				e.printStackTrace();
			}
	    }
	    System.out.println("");
	    if(eb.getA()==2){
		    System.out.println("eb.getD() ="+eb.getD().toString());
	    	try {
				JSONObject d = new JSONObject(eb.getD().toString());
			    System.out.println("d ="+d.toString());
		    	DB db =  gson.fromJson(d.toString(), DB.class);
			    System.out.println("db ="+db.toString());
			} catch (Exception e) {
				e.printStackTrace();
			}
	    }
	    System.out.println("");
	    if(ec.getA()==3){
		    System.out.println("ec.getD() ="+ec.getD().toString());
	    	try {
				JSONObject d = new JSONObject(ec.getD().toString());
			    System.out.println("d ="+d.toString());
		    	DC dc =  gson.fromJson(d.toString(), DC.class);
			    System.out.println("dc ="+dc.toString());
			} catch (Exception e) {
				e.printStackTrace();
			}
	    }
	}
}
运行结果： 

ea =Entity [a=1, b=Hello,world!, c=true, d={aa=1.0}]
eb =Entity [a=2, b=Hello,world!, c=true, d={ba=1.0, bb=Hello word!}]
ec =Entity [a=3, b=Hello,world!, c=true, d={ca=1.0, cb=Hello,:world!, cc=true}]
ea.getD() ={aa=1.0}
d ={"aa":1}
da =DA [aa=1]

eb.getD() ={ba=1.0, bb=Hello word!}
d ={"bb":"Hello word!","ba":1}
db =DB [ba=1, bb=Hello word!]

ec.getD() ={ca=1.0, cb=Hello,:world!, cc=true}
com.mathworks.toolbox.javabuilder.external.org.json.JSONException: Missing value at character 18 of {ca=1.0, cb=Hello,:world!, cc=true}
	at com.mathworks.toolbox.javabuilder.external.org.json.JSONTokener.syntaxError(JSONTokener.java:451)
	at com.mathworks.toolbox.javabuilder.external.org.json.JSONTokener.nextValue(JSONTokener.java:349)
	at com.mathworks.toolbox.javabuilder.external.org.json.JSONObject.<init>(JSONObject.java:191)
	at com.mathworks.toolbox.javabuilder.external.org.json.JSONObject.<init>(JSONObject.java:327)
	at com.example.json.jsontest.main(jsontest.java:51)


当字符串中包含,:等特殊符号时不能正确解析。原因是形如{ca=1.0, cb=Hello,:world!, cc=true}的字符串不能转换为json数据。 

当dataC = "{a:3, b:'Hello,world!', c:true, d:{ca:1, cb:'Hello,world!', cc:true}}";
报错
com.mathworks.toolbox.javabuilder.external.org.json.JSONException: Expected a ':' after a key at character 25 of {ca=1.0, cb=Hello,world!, cc=true}at com.mathworks.toolbox.javabuilder.external.org.json.JSONTokener.syntaxError(JSONTokener.java:451)at com.mathworks.toolbox.javabuilder.external.org.json.JSONObject.<init>(JSONObject.java:204)at com.mathworks.toolbox.javabuilder.external.org.json.JSONObject.<init>(JSONObject.java:327)at com.example.json.jsontest.main(jsontest.java:51) 






当dataC = "{a:3, b:'Hello,world!', c:true, d:{ca:1, cb:'Hello:world!', cc:true}}";
报错
com.mathworks.toolbox.javabuilder.external.org.json.JSONException: Expected a ',' or '}' at character 18 of {ca=1.0, cb=Hello:world!, cc=true}
	at com.mathworks.toolbox.javabuilder.external.org.json.JSONTokener.syntaxError(JSONTokener.java:451)
	at com.mathworks.toolbox.javabuilder.external.org.json.JSONObject.<init>(JSONObject.java:223)
	at com.mathworks.toolbox.javabuilder.external.org.json.JSONObject.<init>(JSONObject.java:327)
	at com.example.json.jsontest.main(jsontest.java:51)
当dataC = "{a:3, b:'Hello,world!', c:true, d:{ca:1, cb:'Hello,:world!', cc:true}}";
报错
com.mathworks.toolbox.javabuilder.external.org.json.JSONException: Missing value at character 18 of {ca=1.0, cb=Hello,:world!, cc=true}
	at com.mathworks.toolbox.javabuilder.external.org.json.JSONTokener.syntaxError(JSONTokener.java:451)
	at com.mathworks.toolbox.javabuilder.external.org.json.JSONTokener.nextValue(JSONTokener.java:349)
	at com.mathworks.toolbox.javabuilder.external.org.json.JSONObject.<init>(JSONObject.java:191)
	at com.mathworks.toolbox.javabuilder.external.org.json.JSONObject.<init>(JSONObject.java:327)
	at com.example.json.jsontest.main(jsontest.java:51)
如果收到的json数据是dataC = "{a:3, b:'Hello,world!', c:true, d:{ca:1, cb:\'\"Hello,world!\"\', cc:true}}";则可以解析，因为第一次解析得到的是{ca=1.0, cb="Hello,world!", cc=true}，可以转换成json数据，但是别人不可能按我的需求这样发给我。可怜



然后在网上继续找字符串转换为实体类，发现很多人说啥反射工厂模式，觉得意思就和编译原理里的词法分析、语法分析差不多，就是一个一个地进行匹配，然后我就像下面这样做。


jsonsubtest.java






import com.google.gson.Gson;

public class jsonsubtest {
	public static void main(String[] args) {
		String dataA = "{a:1, b:'Hello,world!', c:true, d:{aa:1}}";
		String dataB = "{a:2, b:'Hello,world!', c:true, d:{ba:1, bb:'Hello word!'}}";
		String dataC = "{a:3, b:'Hello,world!', c:true, d:{ca:1, cb:'Hello,world!', cc:true}}";
	    Gson gson = new Gson();  
	    DC dctest = new DC(1, null, false);
	    String jsondctest = gson.toJson(dctest, DC.class);
	    System.out.println("jsondctest ="+jsondctest);
	    
	    Entity ea = gson.fromJson(dataA, Entity.class);
	    Entity eb = gson.fromJson(dataB, Entity.class);
	    Entity ec = gson.fromJson(dataC, Entity.class);

	    System.out.println("ea ="+ea.toString());
	    System.out.println("eb ="+eb.toString());
	    System.out.println("ec ="+ec.toString());

	    DC dc1 = getD(ec.getD().toString());
	    System.out.println("dc1 ="+dc1.toString());
	    DC dc2 = getD("{ca=1.0, cc=true}");
	    System.out.println("dc2 ="+dc2.toString());
	    DC dc3 = getD("{ca=1.0, cb=Hello,cc=world!, cc=true}");
	    System.out.println("dc3 ="+dc3.toString());
	    DC dc4 = getDcut("{ca=1.0, cb=Hello,cc=world!, cc=true}");
	    System.out.println("dc4 ="+dc4.toString());
	    DC dc5 = getDcut("{ca=1.0, cb=Hello, cc=world!, cc=true}");
	    System.out.println("dc5 ="+dc5.toString());
	}
	public static DC getD(String srcstr) {//{ca=1.0, cb=Hello,world!, cc=true} {ca=1.0, cc=true}
		int a = 0;
		String b = null;
		boolean c = false;
		String temp = "";
		int start,end = 0;
		start = srcstr.indexOf("ca=");
		if(start!=-1){
			temp = srcstr.substring(start);
			end = temp.indexOf(", ");
			if(end!=-1)
				a = (int) Float.parseFloat(temp.substring(3, end));
		}
		start = srcstr.indexOf("cb=");
		if(start!=-1){
			temp = srcstr.substring(start);
			end = temp.indexOf(", cc");
			if(end!=-1)
				b = temp.substring(3, end);
		}
		start = srcstr.indexOf("cc=");
		if(start!=-1){
			temp = srcstr.substring(start);
			end = temp.indexOf("}");
			if(end!=-1)
				c = Boolean.parseBoolean(temp.substring(3, end));
		}
		DC dc = new DC(a, b, c);
		return dc;
	}
	private static DC getDcut(String srcstr) {
		int a = 0;
		String b = null;
		boolean c = false;
		String temp = "";
		int start,end = 0;
	    System.out.println("srcstr1 ="+srcstr);
		start = srcstr.indexOf("ca=");
		if(start!=-1){
			temp = srcstr.substring(start);
			end = temp.indexOf(", ");
			if(end!=-1)
				a = (int) Float.parseFloat(temp.substring(3, end));
		}
		if(start!=-1 && end!=-1){
			temp = srcstr.substring(start, end+2);
			srcstr = srcstr.replace(temp, "");
		}
	    System.out.println("srcstr2 ="+srcstr);
		start = srcstr.indexOf("cb=");
		if(start!=-1){
			temp = srcstr.substring(start);
			end = temp.indexOf(", cc");
			if(end!=-1)
				b = temp.substring(3, end);
		}
		if(start!=-1 && end!=-1){
			temp = srcstr.substring(start, end+4);
			srcstr = srcstr.replace(temp, "");
		}
	    System.out.println("srcstr3 ="+srcstr);
		start = srcstr.indexOf("cc=");
		if(start!=-1){
			temp = srcstr.substring(start);
			end = temp.indexOf("}");
			if(end!=-1)
				c = Boolean.parseBoolean(temp.substring(3, end));
		}
		DC dc = new DC(a, b, c);
		return dc;
	}
}
运行结果：





jsondctest ={"ca":1,"cc":false}
ea =Entity [a=1, b=Hello,world!, c=true, d={aa=1.0}]
eb =Entity [a=2, b=Hello,world!, c=true, d={ba=1.0, bb=Hello word!}]
ec =Entity [a=3, b=Hello,world!, c=true, d={ca=1.0, cb=Hello,world!, cc=true}]
dc1 =DC [ca=1, cb=Hello,world!, cc=true]
dc2 =DC [ca=1, cb=null, cc=true]
dc3 =DC [ca=1, cb=Hello,cc=world!, cc=false]
srcstr1 ={ca=1.0, cb=Hello,cc=world!, cc=true}
srcstr2 ={ cb=Hello,cc=world!, cc=true}
srcstr3 ={ cc=true}
dc4 =DC [ca=1, cb=Hello,cc=world!, cc=true]
srcstr1 ={ca=1.0, cb=Hello, cc=world!, cc=true}
srcstr2 ={ cb=Hello, cc=world!, cc=true}
srcstr3 ={ cc=world!, cc=true}
dc5 =DC [ca=1, cb=Hello, cc=false]
尴尬结果真是不忍直视。



后来在http://blog.youkuaiyun.com/yuanguozhengjust/article/details/50477128才发现可以这样做。


EntityT.java






public class EntityT <T>{
	private int a;
	private String b;
	private boolean c;
	private T d;
	public int getA() {
		return a;
	}
	public void setA(int a) {
		this.a = a;
	}
	public String getB() {
		return b;
	}
	public void setB(String b) {
		this.b = b;
	}
	public boolean isC() {
		return c;
	}
	public void setC(boolean c) {
		this.c = c;
	}
	public T getD() {
		return d;
	}
	public void setD(T d) {
		this.d = d;
	}
	@Override
	public String toString() {
		return "EntityT [a=" + a + ", b=" + b + ", c=" + c + ", d=" + d + "]";
	}
}
jsonentitytest.java





import java.lang.reflect.Type;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;

public class jsonentitytest {
	public static void main(String[] args) {
		String dataA = "{a:1, b:'Hello,world!', c:true, d:{aa:1}}";
		String dataB = "{a:2, b:'Hello,world!', c:true, d:{ba:1, bb:'Hello word!'}}";
		String dataC = "{a:3, b:'Hello,world!', c:true, d:{ca:1, cb:'Hello,world!', cc:true}}";
//		String dataA = "{a:1, b:'Hello,world!', c:true, d:{aa:1}}";
//		String dataB = "{a:2, b:'Hello,world!', c:true, d:{ba:1, bb:\'\"Hello,word!\"\'}}";
//		String dataC = "{a:3, b:'Hello,world!', c:true, d:{ca:1, cb:\'\"Hello,world!\"\', cc:true}}";
//		String dataA = "{\"a\":1, \"b\":\"Hello,world!\", \"c\":true, \"d\":{\"aa\":1}}";
//		String dataB = "{\"a\":2, \"b\":\"Hello,world!\", \"c\":true, \"d\":{\"ba\":1, \"bb\":\'\"Hello,world!\"\'}}";
//		String dataC = "{\"a\":3, \"b\":\"Hello,world!\", \"c\":true, \"d\":{\"ca\":1, \"cb\":\'Hello,world!\', \"cc\":true}}";
	    Gson gson = new Gson();  
	    
	    DC dctest = new DC(1, null, false);
	    String jsondctest = gson.toJson(dctest, DC.class);
	    System.out.println("jsondctest ="+jsondctest);
	    
	    EntityT ea = gson.fromJson(dataA, EntityT.class);
	    EntityT eb = gson.fromJson(dataB, EntityT.class);
	    EntityT ec = gson.fromJson(dataC, EntityT.class);

	    System.out.println("ea ="+ea.toString());
	    System.out.println("eb ="+eb.toString());
	    System.out.println("ec ="+ec.toString());

	    System.out.println("");
	    if(ea.getA()==1){
	        Type jsonType = new TypeToken<EntityT<DA>>() {}.getType();  
	    	ea = gson.fromJson(dataA, jsonType); 
		    System.out.println("ea ="+ea.toString());
	    }
	    if(eb.getA()==2){
	        Type jsonType = new TypeToken<EntityT<DB>>() {}.getType();  
	    	eb = gson.fromJson(dataB, jsonType); 
		    System.out.println("eb ="+eb.toString());
	    }
	    if(ec.getA()==3){
	        Type jsonType = new TypeToken<EntityT<DC>>() {}.getType();  
	    	ec = gson.fromJson(dataC, jsonType); 
		    System.out.println("ec ="+ec.toString());
	    }
	}
}



至此已经能满足我的需求了，也没精神再找新方法了，睡觉睡觉


本文链接http://blog.youkuaiyun.com/qq_25189723/article/details/78848521


                

        

    

    
  



    



                



	

		

			

				
					
JSONObject 【解析JSON格式】使用Gson库解析包含数组的JSON

				
			

			

				

					王大师企业官方博客
				

				

					06-22
					
					1万+
					
				

			

		

		

			
				
学习教程（传送门）本人详解作者：王文峰，参加过 优快云 2020年度博客之星，《Java王大师王天师》公众号：JAVA开发王大师，专注于天道酬勤的 Java 开发问题中国国学、传统文化和代码爱好者的程序人生，期待你的关注和支持！本人外号：神秘小峯 山峯转载说明：务必注明来源（注明：作者：王文峰哦）【解析JSON格式】使用Gson库解析包含数组的JSON学习教程（传送门）学习教程（传送门）往期文章学习教程（传送门）1、掌握入门到进阶知识(持续写作中……2、学会数据库用法(

			
		

	



                

            
              



	

		

			

				
					
 gson解析器实现json和实体类对象互转源代码

				
			

			

				

					07-18
				

			

		

		

			
				
在本文中，我们将深入探讨Gson解析器的工作原理以及如何利用它来实现JSON和实体类对象之间的互转。  1. **Gson简介**  Gson库的核心功能在于提供了一种直观的方式来将Java对象转换为它们对应的JSON表示，反之亦然。...

			
		

	



              


  
              

                


	

		

			

				
					
Gson解析json对不确定泛型的处理

				
			

			

				

					hunter800421的专栏
				

				

					04-19
					
					5356
					
				

			

		

		

			
				
最近项目中遇到个问题，服务端返回的json数据中，有个object中的内容是不确定的，条目不确定，key的值也不确定。我们使用的是Gson解析json。对于Gson，要把json转化为对应的实体对象，在不知道json object内部结构的情况下，这似乎不太好解决。

比如，这样的json：
"{a:1, b:'Hello,world!', c:{d:5,e:'gson'}}";
其中ke

			
		

	





	

		

			

				
					
java未指定主类,java-GSON解析未指定的类型变量

				
			

			

				

					weixin_29410959的博客
				

				

					03-15
					
					368
					
				

			

		

		

			
				
我使用GSON库解析服务器JSON响应.后端人员有时会告诉我：“由于某种原因,我们无法在JSON中指定变量类型”(旧的php,他们不知道如何执行操作,依此类推等等).GSON喜欢在对象模型中进行强类型化.因此,我无法将Object解析为String.GSON等待：{"service":{"description":null,"name":"Base","id":"4c7a90410529"}}但是...

			
		

	



		

			
		



	

		

			

				
					
深入理解Gson：Google的Java JSON库解析指南

					
最新发布

				
			

			

				

					weixin_36238982的博客
				

				

					06-13
					
					1273
					
				

			

		

		

			
				
JSON（JavaScript Object Notation）作为一种轻量级的数据交换格式，因其结构简单、易于阅读和编写以及跨平台特性而被广泛应用于网络数据交换。相较于其他数据交换格式，如XML，JSON格式在前后端数据交互中因其简洁性和灵活性而备受欢迎。在使用Gson处理JSON数据时，我们经常遇到一些特殊情况，如日期类型、枚举类型等不能直接序列化与反序列化的类型。这时，我们可以通过自定义类型适配器来解决这些问题。类型适配器可以让我们在序列化和反序列化过程中自定义行为，以适应特定的数据处理需求。

			
		

	





	

		

			

				
					
GSON 解析json 无需在手动解析实体类

				
			

			

				

					churanxian6085的博客
				

				

					03-17
					
					453
					
				

			

		

		

			
				
实体类的父类
该类下 Json2bean 是把json转成实体类
Json2ListBean 吧json转成 list<实体类>
GSON使用注意项 ：json属性名和实体的属性名必须一致，不一致则赋值为空。
 <!-- lang: java -->
/** 


Fi...

			
		

	





	

		

			

				
					
android不确定json对象类型,Android中解析不规则json的理解(基于Gson)

				
			

			

				

					weixin_36354351的博客
				

				

					05-26
					
					288
					
				

			

		

		

			
				
public classNOO {/*** result : 1* message : 成功！* list : {"0":{"glj_price":200,"lrj_price":895.98,"fdj_price":707.94,"allmoney":1803.92,"rq":"2017-08"},"7":{"glj_price":0,"lrj_price":0,"fdj_price":60,"...

			
		

	





	

		

			

				
					
android Gson解析未知格式Json内容问题

				
			

			

				

					s13488941815的专栏
				

				

					03-06
					
					1050
					
				

			

		

		

			
				
在Gson中，我们解析json里的固定字段非固定内容通常是通过泛型<T>封装

如


class Result<T>

{

public String type;

public T data;

}

这种方式我们在使用时，必须先定义泛型的类型才能去解析json字符串；

但是，实际需求中，我们可能会出现我们的请求是确认的，但是返回的字段内容是不确定的，比如说data...

			
		

	





	

		

			

				
					
Gson解析JSON对象转User实体类示例

				
			

			

				

					
				

			

		

		

			
				
在Gson解析的场景中，`User`实体类通常是一个包含字段和对应getter/setter方法的Java类，用于映射JSON数据中的键值对。例如：  ```java public class User {  private String name;  private int age;   // Getter ...

			
		

	





	

		

			

				
					
Android JSON数据与实体类之间的相互转化（GSON的用法）

				
			

			

				

					01-04
				

			

		

		

			
				
这篇文章就是示范如何用GSON把JSON数据与实体类进行相互转化,需要用到gson-2.3.1.jar这个包。直接贴代码了:   import java.lang.reflect.Type; import java.util.ArrayList; import java.util.List; import ...

			
		

	





	

		

			

				
					
gson解析json

				
			

			

				

					08-16
				

			

		

		

			
				
 使用Gson解析JSON：  ```java  Gson gson = new Gson();  Person person = gson.fromJson(jsonString, Person.class);  ```  3. **生成JSON字符串**  对于已经存在的Java对象，我们可以使用Gson将其转换为JSON字符...

			
		

	





	

		

			

				
					
JSON解析使用实例（非使用实体类）

				
			

			

				

					张平的专栏
				

				

					03-20
					
					1453
					
				

			

		

		

			
				
json解析实例

			
		

	





	

		

			

				
					
Google的Gson不写类模板，直接解析Json，获取属性值的方法

				
			

			

				

					lc林奇的专栏
				

				

					11-22
					
					4197
					
				

			

		

		

			
				
一般用法
public static String toJson(Object obj) {  
        Gson gson = new Gson();  
        return gson.toJson(obj);  
 }
public static  T fromJson(String str, Type type) {
  

Gson gson = new

			
		

	





	

		

			

				
					
gson解析json问题总结

				
			

			

				

					weixin_30773135的博客
				

				

					04-15
					
					320
					
				

			

		

		

			
				
一、使用gson解析json数据时，如果出现某一个属性为null的情况（且并无报错信息），首先检查json文件的属性名称和实体类的属性名称是否一致。
举例如下（正常情况，此处读取本地的一个json文件）：
json文件

{"name":"Tim",
"age":"40",
"job":"basketball",
"hobby":"dai"}

解析代码如下

String ...

			
		

	





	

		

			

				
					
Gson针对API返回字段类型不确定的解决办法

				
			

			

				

					weixin_33866037的博客
				

				

					08-07
					
					1665
					
				

			

		

		

			
				
遇到问题
最近得到用户反馈，有些界面请求数据失败，调试接口发现，是后台返回的类型不确定导致的，例如：
这是一段我们需要的正常json:
{
    "id":1,
    "number":100000000,
    "user":{
        "name":"aoteman",
        "userId":110
    }
}
复制代码但是后台有时会返回这样一段json:
{
 ...

			
		

	





	

		

			

				
					
安卓使用Gson转化为Json数据出现中文乱码的解决方式

				
			

			

				

					我是小彬彬
				

				

					10-10
					
					5495
					
				

			

		

		

			
				
Gson转化为Json的时候，出现了乱码

			
		

	





	

		

			

				
					
[Hutool.JSONUtil]字符串解析报错 cn.hutool.json.JSONException: Expected a ‘:‘ after a key at 5

				
			

			

				

					weixin_43785855的博客
				

				

					07-10
					
					7346
					
				

			

		

		

			
				
字符串解析报错cn.hutool.json.JSONException: Expected a ‘:’ after a key at 5。
使用`JSONUtil.toJsonStr`可以将任意对象（Bean、Map、集合等）直接转换为JSON字符串。 如果对象是有序的Map等对象，则转换后的JSON字符串也是有序的。

			
		

	





	

		

			

				
					
json 基础知识

				
			

			

				

					fengkuangshixisheng的专栏
				

				

					01-04
					
					610
					
				

			

		

		

			
				
JSON对象是一个无序的"名称/值"对的集合它开始于“{”，结束于“}”。每一个属性名和值间用“:”提示，属性间用“,”分隔。一个数组开始于"["，结束于"]"，值之间用","分隔。

数组和List转换为JSON用JSONArray.fromObject 
Map、bean、beans(保存在一个List中转换)转换为JSON用 JSONObject.fromObjectJSONObjec

			
		

	





	

		

			

				
					
JSON转对象报after a key at character 8 of [{&quot

				
			

			

				

					lwx356481的博客
				

				

					11-30
					
					5706
					
				

			

		

		

			
				
前台传回来的数据，就多了很多的&amp;quot这个符号，然后用JSONArray.fromObject()解析的时候报错after a key at character 8 of [{&amp;quot。。。



[
 {
 &amp;quot;qNo&amp;quot;:1,
 &amp;quot;topicId&amp;quot;:&amp;quot;F90EF69302724239BCA...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值