javajson定义

⑴ java解析json格式文件，再保存在数据库怎么做

java解析json格式文件，再保存在数据库的方法：

1:定义一个实体类

2:用json lib将json字符串转为Java对象

3:用jdbc或hibernate将java对象存入数据库

直接读写文件，再把读出来的文件内容格式化成json，再用JDBC、Mybatis或者其他框架将json数据存入数据库。

假设实体类是这样的：

publicclassElectSet{
publicStringxueqi;
publicStringxuenian;
publicStringstartTime;
publicStringendTime;
publicintmenshu;
publicStringisReadDB;
//{"xueqi":,"xuenian":,"startTime":,"endTime":,"renshu":,"isReadDB":}
publicStringgetXueqi(){
returnxueqi;
}
publicvoidsetXueqi(Stringxueqi){
this.xueqi=xueqi;
}
publicStringgetXuenian(){
returnxuenian;
}
publicvoidsetXuenian(Stringxuenian){
this.xuenian=xuenian;
}
publicStringgetStartTime(){
returnstartTime;
}
publicvoidsetStartTime(StringstartTime){
this.startTime=startTime;
}
publicStringgetEndTime(){
returnendTime;
}
publicvoidsetEndTime(StringendTime){
this.endTime=endTime;
}
publicintgetMenshu(){
returnmenshu;
}
publicvoidsetMenshu(intmenshu){
this.menshu=menshu;
}
publicStringgetIsReadDB(){
returnisReadDB;
}
publicvoidsetIsReadDB(StringisReadDB){
this.isReadDB=isReadDB;
}

}

有一个json格式的文件，存的信息如下：

Sets.json:
{"xuenian":"2007-2008","xueqi":"1","startTime":"2009-07-1908:30","endTime":"2009-07-2218:00","menshu":"10","isReadDB":"Y"}

具体操作：

/*
*取出文件内容，填充对象
*/
publicElectSetfindElectSet(Stringpath){
ElectSetelectset=newElectSet();
Stringsets=ReadFile(path);//获得json文件的内容
JSONObjectjo=JSONObject.fromObject(sets);//格式化成json对象
//System.out.println("------------"jo);
//Stringname=jo.getString("xuenian");
//System.out.println(name);
electset.setXueqi(jo.getString("xueqi"));
electset.setXuenian(jo.getString("xuenian"));
electset.setStartTime(jo.getString("startTime"));
electset.setEndTime(jo.getString("endTime"));
electset.setMenshu(jo.getInt("menshu"));
electset.setIsReadDB(jo.getString("isReadDB"));
returnelectset;
}
//设置属性，并保存
publicbooleansetElect(Stringpath,Stringsets){
try{
writeFile(path,sets);
returntrue;
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
returnfalse;
}
}
//读文件，返回字符串
publicStringReadFile(Stringpath){
Filefile=newFile(path);
BufferedReaderreader=null;
Stringlaststr="";
try{
//System.out.println("以行为单位读取文件内容，一次读一整行：");
reader=newBufferedReader(newFileReader(file));
StringtempString=null;
intline=1;
//一次读入一行，直到读入null为文件结束
while((tempString=reader.readLine())!=null){
//显示行号
System.out.println("line"line":"tempString);
laststr=laststrtempString;
line;
}
reader.close();
}catch(IOExceptione){
e.printStackTrace();
}finally{
if(reader!=null){
try{
reader.close();
}catch(IOExceptione1){
}
}
}
returnlaststr;
}

将获取到的字符串，入库即可。

⑵ 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如何定义.剩下的就非常简单了.

⑶ 请问Java中json是什么

一 简介：
JSON（JavaScript对象符号）是一种轻量级的数据交换格式。这是很容易为人类所读取和写入。这是易于机器解析和生成。它是基于JavaScript编程语言的一个子集 ， 标准ECMA-262第三版- 1999年12月。JSON是一个完全独立于语言的文本格式，但使用C家族的语言，包括C，C + +，C＃，Java中的JavaScript，Perl的，Python中，和许多其他程序员所熟悉的约定。这些特性使JSON成为理想的数据交换语言。他和map很类似，都是以
键/值 对存放的。

⑷ java中如何定义一个json串

JSONObject sku= new JSONObject("{\"name\",\"value\"}");

⑸ java里的JSONObject作用是什么什么时候用

JsonObject 就是常说的 json。是一种重要的数据传输对象。其格式为{"key1":value1,"key2",value2....};key 必须是字符串。

因为ajax请求不刷新页面，但配合js可以实现局部刷新，因此json常常被用来作为异步请求的返回对象使用。

通过response.getWriter()获取PrintWriter pw,然后pw.print(json)。如果没有设置response.setContentType("application/json; charset=utf-8"); 则需要自己再js中进行解析。

(5)javajson定义扩展阅读

Java中交互方式分为同步和异步两种：

同步交互：指发送一个请求,需要等待返回,然后才能够发送下一个请求，有个等待过程；

异步交互：指发送一个请求,不需要等待返回,随时可以再发送下一个请求，即不需要等待。

区别：一个需要等待，一个不需要等待，在部分情况下，项目开发中都会优先选择不需要等待的异步交互方式。

比如银行的转账系统，对数据库的保存操作等等，都会使用同步交互操作，其余情况都优先使用异步交互。

⑹ java开发,json是干什么的

json其实就是封装了一种数据格式，它使用了自己定义的标准。主要用来在服务器和客户端的浏览器进行数据交换。因为我们常用的表单形式提交数据，有诸多的不便，json解决了一些问题。

⑺ java中json对象是如何创建或者转换出来的

JSONObject在JAVA中其实就相当于Map, 可以通过key取到值；
而JAVA对象，一般是JAVA中的model或者domain 模型对象， 这种对象代表的是一个业务的模型，是有明确的意义的， 包括里面的属性类型都是明确定义；
转换成对象之后，操作其中的值就可以用getter,setter方法明确指定，
一般其他人使用的时候也能知道里面有什么，而如果只有一个JSONObject, 使用的时候除了先在控制台输入里面的内容是不知道里面有什么的，
并不适合在JAVA方法中的数据传递使用

⑻ Java里如何应用Json格式数据

json说白了就是一个封装了很多需要数据的字符串，使用起来比XML方便一些。

1. 前台页面：现在在前端用jquery或直接用js都可以读取拆解服务器端传来的json，在struts里通过配置文件会自动把返回结果生成json，使用起来很方便的
   

2. 后台程序：获取前台封装的json，可以直接转换成字符串在读取里边传过来的参数进行查询操作

总之，json还是很方便的，是现在很流行的数据传输载体

辛苦打字，望采纳

⑼ 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 web开发中怎么使用json

JSON建构有两种结构：
json简单说就是javascript中的对象和数组，所以这两种结构就是对象和数组2种结构，通过这两种结构可以表示各种复杂的结构
1、对象：对象在js中表示为“{}”括起来的内容，数据结构为 {key：value，key：value,...}的键值对的结构，在面向对象的语言中，key为对象的属性，value为对应的属性值，所以很容易理解，取值方法为 对象.key 获取属性值，这个属性值的类型可以是 数字、字符串、数组、对象几种。在Java中就是一种Map结构。
2、数组：数组在js中是中括号“[]”扩起来的内容，数据结构为 ["java","javascript","vb",...]，取值方式和所有语言中一样，使用索引获取，字段值的类型可以是 数字、字符串、数组、对象几种。在Java中是一种list结构。
经过对象、数组2种结构就可以组合成复杂的数据结构了。

二、Json in Javascript
使用Json语法创建对象
var people = {"name":"jack","sex":"mail"};
可以通过这种语法创建json对象，用“{}”括起来，用“，”隔开key：value
使用Json语法创建数组
var arr =[value1,value2...];
一个包含多个people的数组 peoples = [{"name":"jack","sex":"mail"},{"name":"lily","sex":"femail"};
Json数组可以通过这种语法创建，用"[]"括起来，数组元素之间用“，”分隔开，下面是这种语法的示意图：

在使用Json格式字符串与服务器交互时候，可以利用Json扩展的方法将字符串转换成一个JavaScript对象，或者将一个对象转换成Json格式字符串。不过先要登录http://www.json.org下载Json2.js文件。引入该包后，js对象直接用toJSONString()装换为字符串格式，字符串可以用parseJSON()转换成js对象。
访问数据
只需用点号表示法来表示数组元素。所以，要想访问 上面peoples列表的第一个条目的名字，只需在 JavaScript 中使用下面这样的代码：
peoples[0].name
利用这样的语法，可以处理任何 JSON 格式的数据，而不需要使用任何额外的 JavaScript 工具包或 API。
修改数据
正如可以用点号和方括号访问数据，也可以按照同样的方式轻松地修改数据：
peoples[0].name = "Rachmaninov";
在将字符串转换为 JavaScript 对象之后，就可以像这样修改变量中的数据。