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

最新推荐文章于 2024-03-01 10:14:36 发布
最新推荐文章于 2024-03-01 10:14:36 发布
阅读量4.8k 收藏 2
点赞数
分类专栏： 程序编程 文章标签： gson json 解析 不确定实体类 Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25189723/article/details/78848521
版权

这几天遇到个解析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.csdn.net/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.csdn.net/qq_25189723/article/details/78848521



                

        

        

    




    

      

        

            

              
                
                  一只小_小菜鸟
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    2
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
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 com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.reflect.TypeToken;
import android.app.Activity;
import android.os

			
		

	



                

              
                



	

		

			

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

				
			

			

				

					07-18
				

			

		

		

			
				
 gson解析器，可实现子类和json字符串之间互转

			
		

	



                


  
              

                


	

		

			

				
					
使用Gson解析数组类型的JSON字符串

					
最新发布

				
			

			

				

					fanfangyu的博客
				

				

					03-01
					
					628
					
				

			

		

		

			
				
要使用Gson解析数组类型的JSON字符串，首先需要创建一个Java类来表示这个数组中的数据类型。方法的参数类型是一个泛型，我们需要指定一个具体的类型来解析JSON数组。在这个例子中，我们使用。来表示我们想要解析的类型是一个泛型列表。在这个例子中，我们创建了一个。类来表示数组中的数据类型。方法将JSON字符串解析为。循环遍历数组并输出每个。

			
		

	





	

		

			

				
					
使用Gson来生成json对象以及解析，以及静态内部Handler类

				
			

			

				

					skyang在路上
				

				

					01-08
					
					946
					
				

			

		

		

			
				
遇到又长又复杂的Json格式的网络请求，如果没有gson，那就是相当头疼的事情了。
有了Gson这个神器，一切问题都不是问题！
本人当看到这个json请求示例时，心里也是打鼓：
{
    "service_ver": "1.0",
    "bot_name": "xx",
    "bot_ver": "1",
    "user_id": "xx&quo

			
		

	



		

			
		



	

		

			

				
					
gson解析JSON——内存对象和实体对象

				
			

			

				

					LearnToPain的博客
				

				

					05-24
					
					303
					
				

			

		

		

			
				
网上学语言有坑
https://www.cnblogs.com/boy1025/p/4551593.html



			
		

	





	

		

			

				
					
使用Gson解析不为空的json字符串，所有字段为空的情况

				
			

			

				

					xiaowang_lj的博客
				

				

					11-06
					
					1227
					
				

			

		

		

			
				
今天在做项目中的一个场景，使用gson解析网络请求返回的json数据，由于不了解项目的混淆，只是做了简单的转换，发现json字符串不为空，但是解析出来的bean实体对象所有字段全部是空，


 launcherInfo = gson.fromJson(response, LauncherRedirectBean.class);

怎么也找不到原因，最后百度了一下，发现与混淆规则有关系，在proguard-rules.pro文件里，加上对应类的混淆排除处理，发现解析出json数据了。


#不混淆com.ex

			
		

	





	

		

			

				
					
JSON解析异常-org.json.JSONException: Expected a ‘:‘ after a key

					
热门推荐

				
			

			

				

					浅浅同学的开发笔记
				

				

					11-23
					
					4万+
					
				

			

		

		

			
				
问题场景后端开发好接口，给发过来接口文档，于是开始开心的使用 GsonFormat 插件 建实体了，然而转换 JSON 时出错。错误现场截图：问题分析JSON 转换失败一般有以下两个原因：
JSON 格式有问题，检查一下格式。
格式没问题，仍然报错，那就是编码问题。例如你的 JSON 文件头里带有编码字符(如utf-8等)，读取字符串时 JSON 串是正常的，但是解析就有异常。
很显然我格式没问题，

			
		

	





	

		

			

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

				
			

			

				

					weixin_43785855的博客
				

				

					07-10
					
					3963
					
				

			

		

		

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

			
		

	





	

		

			

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

				
			

			

				

					lwx356481的博客
				

				

					11-30
					
					5452
					
				

			

		

		

			
				
前台传回来的数据，就多了很多的&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...

			
		

	





	

		

			

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

				
			

			

				

					张平的专栏
				

				

					03-20
					
					1345
					
				

			

		

		

			
				
json解析实例

			
		

	





	

		

			

				
					
接口返回String转JSON报错：Missing value. at character 1 of...

				
			

			

				

					lt2014zmm的博客
				

				

					12-21
					
					5036
					
				

			

		

		

			
				
调用系统接口返回数据为JSON格式的String字符串，在对字符串进行转换为JSONObject的时候出现了异常：Missing value. at character 1 of…。
在通过对String字符串进行**.replace**进行返回数据的梳理后仍无法解决问题。
最终找到一个办法，通过StringEscapeUtils.unescapeJava(“JSON格式String字符串”)进行调整后，将格式进行转义后去掉了多余的符号，字符串正常转换为JSONObject。

...

			
		

	





	

		

			

				
					
gson解析json

				
			

			

				

					08-16
				

			

		

		

			
				
这个是一个通过Gson解析Json的简单实现，以及通过实体类生成Json字符串，里面包含Gson解析包，

			
		

	





	

		

			

				
					
GSON解析复杂的JSON数组 - CSDN博客1

				
			

			

				

					08-04
				

			

		

		

			
				
1.GSON的两个重要方法 1.将要解析的数据如下面的格式 2.必须定义如下一些的实体类数据

			
		

	





	

		

			

				
					
gson-2.0.1.jar-Json解析工具，序列化反序列化，实体类互转Json，免费jar包

				
			

			

				

					07-18
				

			

		

		

			
				
gson-2.0.1.jar-Json解析工具，序列化反序列化，实体类互转Json，免费jar包

			
		

	





	

		

			

				
					
oracle插入、替换回车换行\r\n

				
			

			

				

					qq_25189723的博客
				

				

					04-21
					
					1万+
					
				

			

		

		

			
				
回车是光标回到当前行的开头，换行是光标停在当前位置的下一行，结合就是下一行的开头。如果直接插入\r\n，查出来的数据就是"\r\n"，是'\''r''\''n'4个字符。oracle中回车是chr(13)--\r，换行符是chr(10)--\n。插入:insert into testtable(id, name, val, memo) values (1, 'testinsert1', '123'...

			
		

	





	

		

			

				
					
VC++6.0、VS创建、生成DLL，JAVA调用DLL，VC++、VS调用DLL

				
			

			

				

					qq_25189723的博客
				

				

					07-25
					
					2215
					
				

			

		

		

			
				
JNA、JNative、JInvoke、VC创建DLL、调用测试下载

1-1、VC++6.0创建DLL

新建工程，选择Win32 Dynamic-Link Library，工程名称CreateDLL。点击确定。



一个简单的DLL工程，完成。



新建头文件testdll.h，确定。






​#ifndef TestDll_H_
#define TestDll_H_
#ifdef ...

			
		

	





	

		

			

				
					
C++内存泄露及检查定位代码泄露位置（支持VS2017）

				
			

			

				

					qq_25189723的博客
				

				

					04-02
					
					1335
					
				

			

		

		

			
				
内存泄露：常见的new创建的对象没有delete释放掉，导致内存的泄露，以后这部分空间将无法再被使用，就会产生Heap Leak。

两种方法检查代码中存在的内存泄漏：使用自带的库和使用工具。

一 使用自带的库crtdbg.h

不用安装工具，但需要不断的手动修改中断位置。



#include <crtdbg.h>
int main()
{
    //_CrtSetBreakA...

			
		

	





	

		

			

				
					
GSON解析json含有不确定的泛型实体类，根据键值获取json数据

				
			

			

				

					qq_25189723的博客
				

				

					12-20
					
					1091
					
				

			

		

		

			
				
前面GSON解析json中存在不确定实体类 和GSON解析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!'}}";
S

			
		

	





	

		

			

				
					
怎么根据json字符串解析出相应的实体类

				
			

			

				

					09-04
				

			

		

		

			
				
根据json字符串解析出相应的实体类，一般需要按照以下步骤进行操作：

1. 首先，需要引入相关的json解析库，比如常用的Gson或Jackson。
2. 确保所要解析的json字符串是有效的json格式，可以通过使用在线工具或验证库进行验证。
3. 创建一个与json字符串结构相对应的实体类，即定义一个Java类，包含与json键key相匹配的成员变量和对应的访问方法。
4. 使用json解析库将json字符串转化为Java对象。在Gson中，可以使用Gson的fromJson()方法将json字符串解析为对应实体类的对象。
5. 在解析时，可以通过Gson的fromJson方法的第二个参数，传入一个TypeToken类型的对象，以便解析复杂的数据结构，比如List，Map等。
6. 根据需要，可以进一步操作解析的实体类对象，比如通过实体类的get方法获取对应的值。

示例代码如下：

```java
import com.google.gson.Gson;

public class JsonParser {

    public static void main(String[] args) {
        // json字符串示例
        String jsonString = "{\"id\": 123, \"name\": \"Alice\", \"age\": 20}";

        // 创建实体类
        Person person = new Person();

        // 使用Gson解析json字符串为实体类对象
        Gson gson = new Gson();
        person = gson.fromJson(jsonString, Person.class);

        // 输出解析后的实体类对象的值
        System.out.println("ID: " + person.getId());
        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
    }
}

class Person {
    private int id;
    private String name;
    private int age;

    // 对应的getter和setter方法

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
```

上述代码中，使用Gson解析了一个简单的json字符串，并将解析结果赋值给对应的实体类对象。最后通过实体类的getter方法获取每个字段的值并输出。这样就完成了根据json字符串解析出相应的实体类的过程。

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

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

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值