java解析json包

‘壹’ java 读取文件并解析json格式数据再存入数据库

1:定义一个实体类
2:用json lib将json字符串转为Java对象
3:用jdbc或雹仿隐hibernate将java对象大郑存入数据源厅库

‘贰’ java 解析json有几种方式

JSONObject json = new JSONObject();
这个是java中获取json用的类。
使用它的get和put就能操作json的

‘叁’ java包路径解析成json

我跟你讲一种方式，我刚刚想了一下，你最好是在得到你list数据的时候就开始组装，这样是最好的，得到list数据无非是文件递归嘛，当递归到出口的时候，你就放进去，如果是文件夹也往里放。

代码刚写好了。

importcom.alibaba.fastjson.JSONObject;
importjava.io.File;
importjava.net.URL;
importjava.util.LinkedList;
importjava.util.List;


/**
*@Packagecom.xhxh.
*@Descriptionjsonconvert
*@Authorxiehua
*@Date2019-03-0816:28
*/
publicclassFileDomain{
privateStringname;
privateList<FileDomain>packages=newLinkedList<>();

publicFileDomain(){
}

publicFileDomain(Stringname){
this.name=name;
}

publicList<FileDomain>getPackages(){
returnpackages;
}

publicStringgetName(){
returnname;

}

publicvoidsetName(Stringname){
this.name=name;
}

@Override
publicStringtoString(){
return"FileDomain{"+
"name='"+name+'''+
",packages="+packages+
'}';
}

publicstaticvoidmain(String[]args){
FileDomainfileDomain=newFileDomain("com.xhxh");
fileDomain.readFiles("com.xhxh",fileDomain);
Strings=JSONObject.toJSONString(fileDomain);
System.out.println(s);
}

publicvoidreadFiles(StringscanPackage,FileDomainfileDomain){
URLurl=this.getClass().getClassLoader().getResource(scanPackage.replaceAll("\.","/"));
FileclassDir=newFile(url.getFile());
for(Filefile:
classDir.listFiles()){
if(file.isDirectory()){
FileDomaintemFileDomain=newFileDomain(scanPackage+"."+file.getName());
fileDomain.getPackages().add(temFileDomain);
readFiles(scanPackage+"."+file.getName(),temFileDomain);
}else{
FileDomaintemFileDomain=newFileDomain(scanPackage+"."+file.getName());
fileDomain.getPackages().add(temFileDomain);
}
}
}
}

‘肆’ 用java怎么解析复杂的JSON

json-lib-2.4-jdk15.jar 这个包还另需一下几个包。

jakarta commons-lang 2.5
jakarta commons-beanutils 1.8.0
jakarta commons-collections 3.2.1
jakarta commons-logging 1.1.1
ezmorph 1.0.6

把上边的json定义为一个字符串 str，建议不要直接用还是自己动手写写。这样比较容易掌握方法。

JSONObject ob=JSONObject.fromObject(str);
Object success=ob.get("success");
Object errorMsg=ob.get("errorMsg");
System.out.println(success);
System.out.println(errorMsg);
JSONObject data=ob.getJSONObject("data");
Object total=data.get("total");
System.out.println(total);
JSONArray array=data.getJSONArray("rows");
JSONObject rows=null;
for(int i=0;i<array.size();i++){
rows=array.getJSONObject(i);
Object id=rows.get("id");
System.out.println(id);
Object workName=rows.get("workName");
System.out.println(workName);
Object assigneeName=rows.get("assigneeName");
System.out.println(assigneeName);
Object name=rows.get("name");
System.out.println(name);
Object processInstanceInitiatorName=rows.get("processInstanceInitiatorName");
System.out.println(processInstanceInitiatorName);
Object processInstanceStartTime=rows.get("processInstanceStartTime");
System.out.println(processInstanceStartTime);
Object createTime=rows.get("createTime");
System.out.println(createTime);
Object eDate=rows.get("eDate");
System.out.println(eDate);
}

‘伍’ java解析json字符串数据

这个需要导入个jar包的，自己写太麻烦，而且要考虑特殊字符的转义的。

1. json-lib是一个java类库，提供将Java对象，包括beans, maps, collections, java arrays and XML等转换成JSON，或者反向转换的功能。

2. json-lib 主页 ：http://json-lib.sourceforge.net/

3.执行环境

需要以下类库支持

jakarta commons-lang 2.5

jakarta commons-beanutils 1.8.0

jakarta commons-collections 3.2.1

jakarta commons-logging 1.1.1

ezmorph 1.0.6

4.功能示例

这里通过JUnit-Case例子给出代码示例

packagecom.mai.json;

importstaticorg.junit.Assert.assertEquals;

importjava.util.ArrayList;
importjava.util.Date;
importjava.util.HashMap;
importjava.util.Iterator;
importjava.util.List;
importjava.util.Map;
importnet.sf.ezmorph.Morpher;
importnet.sf.ezmorph.MorpherRegistry;
importnet.sf.ezmorph.bean.BeanMorpher;
importnet.sf.json.JSONArray;
importnet.sf.json.JSONObject;
importnet.sf.json.util.JSONUtils;

importorg.apache.commons.beanutils.PropertyUtils;
importorg.junit.Test;

publicclassJsonLibTest{

/*
*普通类型、List、Collection等都是用JSONArray解析
*
*Map、自定义类型是用JSONObject解析
*可以将Map理解成一个对象，里面的key/value对可以理解成对象的属性/属性值
*即{key1:value1,key2,value2......}
*
*1.JSONObject是一个name:values集合，通过它的get(key)方法取得的是key后对应的value部分(字符串)
*通过它的getJSONObject(key)可以取到一个JSONObject，-->转换成map,
*通过它的getJSONArray(key)可以取到一个JSONArray，
*
*
*/

//一般数组转换成JSON
@Test
publicvoidtestArrayToJSON(){
boolean[]boolArray=newboolean[]{true,false,true};
JSONArrayjsonArray=JSONArray.fromObject(boolArray);
System.out.println(jsonArray);
//prints[true,false,true]
}


//Collection对象转换成JSON
@Test
publicvoidtestListToJSON(){
Listlist=newArrayList();
list.add("first");
list.add("second");
JSONArrayjsonArray=JSONArray.fromObject(list);
System.out.println(jsonArray);
//prints["first","second"]
}


//字符串json转换成json，根据情况是用JSONArray或JSONObject
@Test
publicvoidtestJsonStrToJSON(){
JSONArrayjsonArray=JSONArray.fromObject("['json','is','easy']");
System.out.println(jsonArray);
//prints["json","is","easy"]
}


//Map转换成json，是用jsonObject
@Test
publicvoidtestMapToJSON(){
Mapmap=newHashMap();
map.put("name","json");
map.put("bool",Boolean.TRUE);
map.put("int",newInteger(1));
map.put("arr",newString[]{"a","b"});
map.put("func","function(i){returnthis.arr[i];}");

JSONObjectjsonObject=JSONObject.fromObject(map);
System.out.println(jsonObject);
}

//复合类型bean转成成json
@Test
publicvoidtestBeadToJSON(){
MyBeanbean=newMyBean();
bean.setId("001");
bean.setName("银行卡");
bean.setDate(newDate());

ListcardNum=newArrayList();
cardNum.add("农行");
cardNum.add("工行");
cardNum.add("建行");
cardNum.add(newPerson("test"));

bean.setCardNum(cardNum);

JSONObjectjsonObject=JSONObject.fromObject(bean);
System.out.println(jsonObject);

}

//普通类型的json转换成对象
@Test
publicvoidtestJSONToObject()throwsException{
Stringjson="{name="json",bool:true,int:1,double:2.2,func:function(a){returna;},array:[1,2]}";
JSONObjectjsonObject=JSONObject.fromObject(json);
System.out.println(jsonObject);
Objectbean=JSONObject.toBean(jsonObject);
assertEquals(jsonObject.get("name"),PropertyUtils.getProperty(bean,"name"));
assertEquals(jsonObject.get("bool"),PropertyUtils.getProperty(bean,"bool"));
assertEquals(jsonObject.get("int"),PropertyUtils.getProperty(bean,"int"));
assertEquals(jsonObject.get("double"),PropertyUtils.getProperty(bean,"double"));
assertEquals(jsonObject.get("func"),PropertyUtils.getProperty(bean,"func"));
System.out.println(PropertyUtils.getProperty(bean,"name"));
System.out.println(PropertyUtils.getProperty(bean,"bool"));
System.out.println(PropertyUtils.getProperty(bean,"int"));
System.out.println(PropertyUtils.getProperty(bean,"double"));
System.out.println(PropertyUtils.getProperty(bean,"func"));
System.out.println(PropertyUtils.getProperty(bean,"array"));

ListarrayList=(List)JSONArray.toCollection(jsonObject.getJSONArray("array"));
for(Objectobject:arrayList){
System.out.println(object);
}

}


//将json解析成复合类型对象,包含List
@Test
(){
Stringjson="{list:[{name:'test1'},{name:'test2'}],map:{test1:{name:'test1'},test2:{name:'test2'}}}";
//Stringjson="{list:[{name:'test1'},{name:'test2'}]}";
MapclassMap=newHashMap();
classMap.put("list",Person.class);
MyBeanWithPersondiyBean=(MyBeanWithPerson)JSONObject.toBean(JSONObject.fromObject(json),MyBeanWithPerson.class,classMap);
System.out.println(diyBean);

Listlist=diyBean.getList();
for(Objecto:list){
if(oinstanceofPerson){
Personp=(Person)o;
System.out.println(p.getName());
}
}
}


//将json解析成复合类型对象,包含Map
@Test
(){
//把Map看成一个对象
Stringjson="{list:[{name:'test1'},{name:'test2'}],map:{testOne:{name:'test1'},testTwo:{name:'test2'}}}";
MapclassMap=newHashMap();
classMap.put("list",Person.class);
classMap.put("map",Map.class);
//使用暗示，直接将json解析为指定自定义对象，其中List完全解析,Map没有完全解析
MyBeanWithPersondiyBean=(MyBeanWithPerson)JSONObject.toBean(JSONObject.fromObject(json),MyBeanWithPerson.class,classMap);
System.out.println(diyBean);

System.out.println("dothelistrelease");
List<Person>list=diyBean.getList();
for(Persono:list){
Personp=(Person)o;
System.out.println(p.getName());
}

System.out.println("dothemaprelease");

//先往注册器中注册变换器，需要用到ezmorph包中的类
=JSONUtils.getMorpherRegistry();
MorpherdynaMorpher=newBeanMorpher(Person.class,morpherRegistry);
morpherRegistry.registerMorpher(dynaMorpher);


Mapmap=diyBean.getMap();
/*这里的map没进行类型暗示，故按默认的，里面存的为net.sf.ezmorph.bean.MorphDynaBean类型的对象*/
System.out.println(map);
/*输出:
{testOne=net.sf.ezmorph.bean.MorphDynaBean@f73c1[
{name=test1}
],testTwo=net.sf.ezmorph.bean.MorphDynaBean@186c6b2[
{name=test2}
]}
*/
List<Person>output=newArrayList();
for(Iteratori=map.values().iterator();i.hasNext();){
//使用注册器对指定DynaBean进行对象变换
output.add((Person)morpherRegistry.morph(Person.class,i.next()));
}

for(Personp:output){
System.out.println(p.getName());
/*输出:
test1
test2
*/
}

}}

‘陆’ java如何解析文件夹下的json文件

用文件流读出文件内容，然后再解析。

‘柒’ java中怎样解析webservice返回的json数据

json（javascript Object Notation 的缩写）是一个基于文本的，人类可读的，开放标准的轻量级数据交换格式。它继承了javascript中的简单数据结构和相关数组对象，称为对象。不管它 和javascript的瓜葛，json是语言独立的，几乎所有编程语言都能解析咐笑槐它。

json以键值对来表示数据。每个值被一个键名字引用（键名字是个string）。如果你想以衡友json表示人名，他们的名字将被"name"键引用，如下：
“name” : “James”
所以json用一种升缺容易被应用程序传递的方式表现数据，非常完美。
所以当从webservice解析数据时，你要做的第一件事就是搞清楚你的模型。下面我们会分析webservice的响应数据，搞清楚哪些bit代表对象，对象数组，对象所属的字段，等等。
但是json可以表示哪些类型的数据呢？
1.对象是大括号内的所有东东
2.字符串用双引号
3.数字只是简单的显示，如 12345
4. 数组由中括号包围
5.布尔值从'true'和'false'获得，没有引号
6.null值由'null'表示，没有引号

‘捌’ 如何java解析json数组

工具/原料

• 安装有eclipse软件的电脑一台

方法/步骤

• 1

  首先我们在eclipse中创建一个java工程，在java工程中创建一个HelloWorld的类，在这个java的入口程序中，我们来创建一个json字符串，并且打印出来，如下图：

  

‘玖’ java怎么使用gson解析json字符串

Gson是谷歌推出的解析json数据以及将对象转换成json数据的一个开源框架. 现在json因其易读性和高效率而被广泛的使用着.

相对于java以及其它json的解析框架,Gson非常的好用.

简单来讲就是根据json的数据结构定义出相应的javabean --->"new"出Gson的实例gson---->gson.fromJson(jsonString,JavaBean.class) 即可.

下面给出一个实例来说明.

步骤1:目标:将从webservice传回的json

{
"status":0,
"result":{
"location":{
"lng":103.98964143811,
"lat":30.586643130352
},
"formatted_address":"四川省成都市双流县北一街154",
"business":"簇桥,金花桥",
"addressComponent":{
"city":"成都市",
"district":"双流县",
"province":"四川省",
"street":"北一街",
"street_number":"154"
},
"cityCode":75
}
}

先普及下json数据格式定义: json数据只有两种格式.

一种是对象: 一个大括号包裹的内容就是一个对象.里面是无数个逗号相间隔的键值对

{"firstName":"Brett","lastName":"McLaughlin","email":"aaaa"}

一种是数组:一个方括号包裹的内容就是一个数组,里面是无数个逗号相间隔的json对象

如:

{
"people":[
{
"firstName":"Brett",
"lastName":"McLaughlin",
"email":"aaaa"
},
{
"firstName":"Jason",
"lastName":"Hunter",
"email":"bbbb"
},
{
"firstName":"Elliotte",
"lastName":"Harold",
"email":"cccc"
}
]
}

步骤2 定义json数据格式对应的javaBean

publicclassResult{
privateIntegerstatus;
privateResultDetailresult;
publicResult(){
}
publicResult(Integerstatus,ResultDetailresult){
super();
this.status=status;
this.result=result;
}
publicResultDetailgetResult(){
returnthis.result;
}
publicIntegergetStatus(){
returnthis.status;
}
publicvoidsetResult(ResultDetailresult){
this.result=result;
}
publicvoidsetStatus(Integerstatus){
this.status=status;
}
@Override
publicStringtoString(){
return"Result[status="+this.status+",result="+this.result
+"]";
}
}
publicclassResultDetail{
Locationlocation;
Stringformatted_address;
;
Stringbusiness;
StringcityCode;
publicResultDetail(){
super();
//TODOAuto-generatedconstructorstub
}
publicResultDetail(Locationlocation,Stringformatted_address,
,Stringbusiness,StringcityCode){
super();
this.location=location;
this.formatted_address=formatted_address;
this.addressComponent=addressComponent;
this.business=business;
this.cityCode=cityCode;
}
(){
returnthis.addressComponent;
}
publicStringgetBusiness(){
returnthis.business;
}
publicStringgetCityCode(){
returnthis.cityCode;
}
publicStringgetFormatted_address(){
returnthis.formatted_address;
}
publicLocationgetLocation(){
returnthis.location;
}
publicvoidsetAddressComponent(){
this.addressComponent=addressComponent;
}
publicvoidsetBusiness(Stringbusiness){
this.business=business;
}
publicvoidsetCityCode(StringcityCode){
this.cityCode=cityCode;
}
publicvoidsetFormatted_address(Stringformatted_address){
this.formatted_address=formatted_address;
}
publicvoidsetLocation(Locationlocation){
this.location=location;
}
}
publicclassLocation{
Stringlng;
Stringlat;
publicLocation(){
}
publicLocation(Stringlng,Stringlat){
this.lng=lng;
this.lat=lat;
}
publicStringgetLat(){
returnthis.lat;
}
publicStringgetLng(){
returnthis.lng;
}
publicvoidsetLat(Stringlat){
this.lat=lat;
}
publicvoidsetLng(Stringlng){
this.lng=lng;
}
@Override
publicStringtoString(){
return"Location[lng="+this.lng+",lat="+this.lat+"]";
}
}
publicclassAddressComponent{
Stringcity;
Stringdistrict;
Stringprovince;
Stringstreet;
Stringstreet_number;
publicAddressComponent(){
super();
//TODOAuto-generatedconstructorstub
}
publicAddressComponent(Stringcity,Stringdistrict,Stringprovince,
Stringstreet,Stringstreet_number){
super();
this.city=city;
this.district=district;
this.province=province;
this.street=street;
this.street_number=street_number;
}
publicStringgetCity(){
returnthis.city;
}
publicStringgetDistrict(){
returnthis.district;
}
publicStringgetProvince(){
returnthis.province;
}
publicStringgetStreet(){
returnthis.street;
}
publicStringgetStreet_number(){
returnthis.street_number;
}
publicvoidsetCity(Stringcity){
this.city=city;
}
publicvoidsetDistrict(Stringdistrict){
this.district=district;
}
publicvoidsetProvince(Stringprovince){
this.province=province;
}
publicvoidsetStreet(Stringstreet){
this.street=street;
}
publicvoidsetStreet_number(Stringstreet_number){
this.street_number=street_number;
}
@Override
publicStringtoString(){
return"AddressComponent[city="+this.city+",district="
+this.district+",province="+this.province+",street="
+this.street+",street_number="+this.street_number+"]";
}
}

测试:

jsonString ( 目标json数据,已经在最上面写好的)

System.out.println("jsonString:"+jsonString);
Gsongson=newGson();
ResultfromJson=gson.fromJson(jsonString.toString(),Result.class);
System.out.println("******************************************");
System.out.println(fromJson);

结果:

jsonString:{"status":0,"result":{"location":{"lng":103.98964143811,"lat":30.586643130352},"formatted_address":"四川省成都市双流县北一街154","business":"簇桥,金花桥","addressComponent":{"city":"成都市","district":"双流县","province":"四川省","street":"北一街","street_number":"154"},"cityCode":75}}
*******************************************
Result[status=0,result=ResultDetail[location=Location[lng=103.98964143811,lat=30.586643130352],formatted_address=四川省成都市双流县北一街154,addressComponent=AddressComponent[city=成都市,district=双流县,province=四川省,street=北一街,street_number=154],business=簇桥,金花桥,cityCode=75]]

可见,jsonString已经成功的被转换成了对应的javaBean

步骤3 : 总结.说明

Gson可以很轻松的实现javaBean和jsonString之间的互转.只需要明白json如何定义.剩下的就非常简单了.