junJZ_2008
- 浏览: 1335881 次
- 性别:
- 来自: 湖南澧縣
-
文章分类
最新评论
-
虾米小尹：
不行啊！2.2-0.25=1.9500000000000002 ...
JavaScript浮点数运算 —— 精度问题 -
heluping000000：
引用String a= "abc",首先在 ...
String，到底创建了多少个对象？ -
mack：
谢谢分享matcher.appendReplacement(s ...
string.replaceAll()中的特殊字符（$ \）与matcher.appendReplacement -
wzt3309：
完全理解，比网上其他资料都要详细
String，到底创建了多少个对象？ -
u014771876：
Java中十六进制转换 Integer.toHexString()
转换时Bean所要求的：
- 被转换的Bean必需是public的。
- Bean被转换的属性一定要有对应的get方法，且一定要是public的。
- Bean中不能用引用自身的this的属性，否则运行时出现et.sf.json.JSONException: There is a cycle in the hierarchy!异常
- json-lib包转换时，不能以null为键名，否则运行报net.sf.json.JSONException:java.lang.NullPointerException:JSON keys must not be null nor the 'null' string.
-
json-lib包转换时， 转换成XML元素key的名字要符合XML元素标签的命名规则，否则会报nu.xom.IllegalNameException: NCNames cannot start with the character 25异常
转换时问题：
-
如果某个Bean中存在存放数组的Map属性，则使用org.json包中的JSONObject直接封装时得不到正确的JSON，要用JSONArray对数组进行封装处理，否则为转换JavaScript中的空的对象{}，但能使用json-lib包很好地解决这一问题
两种包的比较：
- json-lib包比org.json要易使用些，至少没有烦人的JSONExcetipn捕获异常了。
- json-lib对Bean的支持比org.json要强，特别是对bean中内嵌属性的支持较好。
- commons-beanutils-1.8.0.jar
- commons-collections-3.2.1.jar
- commons-lang-2.4.jar
- commons-logging-1.1.1.jar
- ezmorph-1.0.6.jar
- json-lib-2.3-jdk15.jar
- xom-1.2.2.jar
- 实例所用到的三个Bean
package bean;
/**
* 创建Address实体类的POJO
* (C) 2009-9-1, jzj
*/
public class Address {
private String street;//街道
private String city;//城市
private int zip;//邮编
private String tel;//第一个电话号码
private String telTwo;//第二个电话号码
public Address() {
}
public Address(String street, String city, int zip, String tel, String telTwo) {
this.street = street;
this.city = city;
this.zip = zip;
this.tel = tel;
this.telTwo = telTwo;
}
//以下是get set 方法
......
}
package bean;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* POJO 定义各种类型的属性，便于测试
* (C) 2009-9-7, jzj
*/
public class OtherBean {
/*
* 定义一个整数属性
*/
private int intAttr = 1;
/*
* 定义一个浮点数属性
*/
private float floatAttr = 1.1f;
/*
* 定义一个布尔型属性
*/
private boolean booleanAttr = true;
/*
* 定义一个空的属性
*/
private Address nullAttr = null;
/*
* 定义一个字符属性
*/
private char charAttr = 'j';
/*
* 定义一个包装类整型属性
*/
private Integer intgerAttr = new Integer(2);
/*
* 定义一个字符属性
*/
private String strAttr = "jzj";
/*
* 定义一个引用其他Bean的属性
*/
private Address addrArr = new Address("changde", "lixian", 72452, "541-322-1723",
"546-338-1100");
/*
* 定义一个字符数组属性
*/
private String[] strArrAttr = new String[] { "str1", "str2" };
/*
* 定义一个字符数组属性
*/
private char[] charArrAttr = new char[] { 'j', 's', 'o', 'n' };
/*
* 定义一个list集合属性
*/
private List listAttr = new ArrayList();
/*
* 定义一个set集合属性
*/
private Set hasSetAttr = new HashSet();
/*
* 定义一个hashMap为存放数组的map属性，如果用
* org.json包转换时则得不到正确有结果json-lib则可以
*/
private Map hashMapAttr = new HashMap();
/**
* 构造器，初始化集合
*/
public OtherBean() {
List tempList = new ArrayList();
tempList.add("one");
tempList.add("two");
listAttr.add("jiang");
listAttr.add(tempList);
listAttr.add(new Address("P.O BOX 54534", "Seattle, WA", 42452, "561-832-3180",
"531-133-9098"));
hasSetAttr.addAll(listAttr);
hashMapAttr.put("first", new String[][] { { "1", "2" }, { "3" } });
hashMapAttr.put("second", new String[][] { { "one", "two" }, { "three" } });
}
//以下是get set方法
......
}
package bean;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import net.sf.json.JSONFunction;
/**
* POJO 定义各种类型的属性，便于测试
* (C) 2009-9-7, jzj
*/
public class Bean {
//其他属性略，在OtherBean的基础上加上了otherBeanAttr属性而已
......
/*
* 定义一个引用复杂实例的属性，这样可以测试属性递归情况
* print：以上各属性值
*/
private OtherBean otherBeanAttr = new OtherBean();
//以下是get set 方法
......
}
- 使用json-lib包进行转换
package jsonlib;
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import junit.framework.TestCase;
import net.sf.ezmorph.bean.MorphDynaBean;
import net.sf.json.JSONArray;
import net.sf.json.JSONFunction;
import net.sf.json.JSONObject;
import net.sf.json.JsonConfig;
import net.sf.json.xml.XMLSerializer;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
import bean.Address;
import bean.Bean;
/**
* 使用json-lib包进行bean、json、xml的数据转换
* (C) 2009-9-6,jzj
*/
public class JSONFormatTest extends TestCase {
public void testDate2Json() {
JSONObject jsonObj = JSONObject.fromObject(new Date());
// print: {"date":10,"day":4,"hours":2,"minutes":2,
//"month":8,"seconds":38,"time":1252519358062,"timezoneOffset":-480,"year":109}
System.out.println(jsonObj.toString());
}
public void testArray2Json() {
JSONArray jsonArr = JSONArray.fromObject(new String[][] { { "one", "two" },
{ "three", "four" } });
// print: [["one","two"],["three","four"]]
System.out.println(jsonArr.toString());
//json串转JSONArray
JSONArray jsArr = JSONArray.fromObject(jsonArr.toString());
//从JSONObject读取数据
//print: three
System.out.println(((JSONArray) jsArr.get(1)).get(0));
System.out.println("\n");
}
public void testList2Json() {
List list = new ArrayList();
list.add(new Integer(1));
list.add(new Boolean(true));
list.add(new Character('j'));
list.add(new char[] { 'j', 's', 'o', 'n' });
list.add(null);
list.add("json");
list.add(new String[] { "json", "-", "lib" });
list.add(new JSONFunction(new String[] { "i" }, "alert(i)"));
list.add(new Address("P.O BOX 54534", "Seattle, WA", 42452, "561-832-3180",
"531-133-9098"));
//list转JSONArray
JSONArray jsArr = JSONArray.fromObject(list);
/*
* list转JSON串
* print: [1,true,"j",["j","s","o","n"],null,"json",["json","-","lib"],
* function(i){ alert(i) },{"city":"Seattle, WA","street":"P.O BOX 54534",
* "tel":"561-832-3180","telTwo":"531-133-9098","zip":42452}]
*/
System.out.println(jsArr.toString(4));
//从JSON串到JSONArray
jsArr = JSONArray.fromObject(jsArr.toString());
//--从JSONArray里读取
//print: json
System.out.println(((JSONArray) jsArr.get(6)).get(0));
//print: address.city = Seattle, WA
System.out.println("address.city = " + ((JSONObject) jsArr.get(8)).get("city"));
System.out.println("\n");
}
public void testMap2Json() throws DocumentException {
Map map = new LinkedHashMap();
map.put("integer", new Integer(1));
map.put("boolean", new Boolean(true));
map.put("char", new Character('j'));
map.put("charArr", new char[] { 'j', 's', 'o', 'n' });
//注:不能以null为键名，否则运行报net.sf.json.JSONException: java.lang.NullPointerException:
//JSON keys must not be null nor the 'null' string.
map.put("nullAttr", null);
map.put("str", "json");
map.put("strArr", new String[] { "json", "-", "lib" });
map.put("jsonFunction", new JSONFunction(new String[] { "i" }, "alert(i)"));
map.put("address", new Address("P.O BOX 54534", "Seattle, WA", 42452,
"561-832-3180", "531-133-9098"));
//map转JSONArray
JSONObject jsObj = JSONObject.fromObject(map);
/*
* map转JSON串
*
* print:{"integer":1,"boolean":true,"char":"j","charArr":["j","s","o","n"],
* "nullAttr":null,"str":"json","strArr":["json","-","lib"],"jsonFunction":
* function(i){ alert(i) },"address":{"city":"Seattle, WA","street":"P.O BOX 54534",
* "tel":"561-832-3180","telTwo":"531-133-9098","zip":42452}}
*/
System.out.println(jsObj.toString(4));
//从JSON串到JSONObject
jsObj = JSONObject.fromObject(jsObj.toString());
//--从JSONObject里读取
//print: json
System.out.println(jsObj.get("str"));
//print: address.city = Seattle, WA
System.out.println("address.city = "
+ ((JSONObject) jsObj.get("address")).get("city"));
//--从动态Bean里读取数据，由于不能转换成具体的Bean，感觉没有多大用处
MorphDynaBean mdBean = (MorphDynaBean) JSONObject.toBean(jsObj);
//print: json
System.out.println(mdBean.get("str"));
//print: address.city = Seattle, WA
System.out.println("address.city = "
+ ((MorphDynaBean) mdBean.get("address")).get("city"));
//--JSONObject转XML
XMLSerializer xmlSerial = new XMLSerializer();
xmlSerial.setRootName("root");
/*注：转换成XML元素key的名字要符合XML元素标签的命名规则，否则会报
nu.xom.IllegalNameException: NCNames cannot start with the character 25异常
print:
<?xml version="1.0" encoding="UTF-8"?>
<root>
<address class="object">
<city type="string">Seattle, WA</city>
<street type="string">P.O BOX 54534</street>
<tel type="string">561-832-3180</tel>
<telTwo type="string">531-133-9098</telTwo>
<zip type="number">42452</zip>
</address>
<boolean type="boolean">true</boolean>
<char type="string">j</char>
<charArr class="array">
<e type="string">j</e>
<e type="string">s</e>
<e type="string">o</e>
<e type="string">n</e>
</charArr>
<integer type="number">1</integer>
<jsonFunction type="function" params="i"><![CDATA[alert(i)]]></jsonFunction>
<nullAttr class="object" null="true"/>
<str type="string">json</str>
<strArr class="array">
<e type="string">json</e>
<e type="string">-</e>
<e type="string">lib</e>
</strArr>
</root>
*/
System.out.println(write2XML(DocumentHelper.parseText(xmlSerial.write(jsObj))));
System.out.println("\n");
}
public void testBean2Json() throws DocumentException {
Bean bean = new Bean();
JSONObject jsonObj = JSONObject.fromObject(bean);
/*print:
{
"booleanAttr": true,
"charArrAttr": [
"j",
"s",
"o",
"n"
],
"charAttr": "j",
"floatAttr": 1.1,
"hasSetAttr": [
"jiang",
[
"one",
"two"
],
{
"city": "Seattle, WA",
"street": "P.O BOX 54534",
"tel": "561-832-3180",
"telTwo": "531-133-9098",
"zip": 42452
}
],
"hashMapAttr": {
"first": [
[
"1",
"2"
],
["3"]
],
"second": [
[
"one",
"two"
],
["three"]
]
},
"intAttr": 1,
"intgerAttr": 2,
"jsonFunctionAttr": function(name){ alert(name) },
"listAttr": [
"jiang",
[
"one",
"two"
],
{
"city": "Seattle, WA",
"street": "P.O BOX 54534",
"tel": "561-832-3180",
"telTwo": "531-133-9098",
"zip": 42452
}
],
"nullAttr": null,
"otherBeanAttr": {
"addrArr": {
"city": "lixian",
"street": "changde",
"tel": "541-322-1723",
"telTwo": "546-338-1100",
"zip": 72452
},
"booleanAttr": true,
"charArrAttr": [
"j",
"s",
"o",
"n"
],
"charAttr": "j",
"floatAttr": 1.1,
"hasSetAttr": [
{
"city": "Seattle, WA",
"street": "P.O BOX 54534",
"tel": "561-832-3180",
"telTwo": "531-133-9098",
"zip": 42452
},
[
"one",
"two"
],
"jiang"
],
"hashMapAttr": {
"first": [
[
"1",
"2"
],
["3"]
],
"second": [
[
"one",
"two"
],
["three"]
]
},
"intAttr": 1,
"intgerAttr": 2,
"listAttr": [
"jiang",
[
"one",
"two"
],
{
"city": "Seattle, WA",
"street": "P.O BOX 54534",
"tel": "561-832-3180",
"telTwo": "531-133-9098",
"zip": 42452
}
],
"nullAttr": null,
"strArrAttr": [
"str1",
"str2"
],
"strAttr": "jzj"
},
"strArrAttr": [
"str1",
"str2"
],
"strAttr": "jzj"
}
*/
System.out.println(jsonObj.toString(4));
//json转JSONObject
jsonObj = JSONObject.fromObject(jsonObj.toString());
//print:Seattle, WA
System.out.println(((JSONObject) ((JSONArray) jsonObj.get("hasSetAttr")).get(2))
.get("city"));
//--JSONObject转Bean
bean = (Bean) JSONObject.toBean(jsonObj, Bean.class);
//注:如果Bean里的某个属性存有数组，则数组转换成list存放，但如果数组为bean属性时转换后还是数组
//print: 1
System.out.println(((List) ((List) bean.getHashMapAttr().get("first")).get(0))
.get(0));
//print: j
System.out.println(((char[]) bean.getCharArrAttr())[0]);
//--Bean转XML
XMLSerializer xmlSerial = new XMLSerializer();
//设置根节点名
xmlSerial.setRootName("root");
JsonConfig jc = new JsonConfig();
//排除不需要转换的属性，排除otherBeanAttr内部引用属性
jc.setExcludes(new String[] { "otherBeanAttr" });
jsonObj = JSONObject.fromObject(bean, jc);
/*
print:
<?xml version="1.0" encoding="UTF-8"?>
<root>
<booleanAttr type="boolean">true</booleanAttr>
<charArrAttr class="array">
<e type="string">j</e>
<e type="string">s</e>
<e type="string">o</e>
<e type="string">n</e>
</charArrAttr>
<charAttr type="string">j</charAttr>
<floatAttr type="number">1.1</floatAttr>
<hasSetAttr class="array">
<e type="string">jiang</e>
<e class="array">
<e type="string">one</e>
<e type="string">two</e>
</e>
<e class="object">
<city type="string">Seattle, WA</city>
<street type="string">P.O BOX 54534</street>
<tel type="string">561-832-3180</tel>
<telTwo type="string">531-133-9098</telTwo>
<zip type="number">42452</zip>
</e>
</hasSetAttr>
<hashMapAttr class="object">
<first class="array">
<e class="array">
<e type="string">1</e>
<e type="string">2</e>
</e>
<e class="array">
<e type="string">3</e>
</e>
</first>
<second class="array">
<e class="array">
<e type="string">one</e>
<e type="string">two</e>
</e>
<e class="array">
<e type="string">three</e>
</e>
</second>
</hashMapAttr>
<intAttr type="number">1</intAttr>
<intgerAttr type="number">2</intgerAttr>
<jsonFunctionAttr type="function" params="name"><![CDATA[alert(name)]]></jsonFunctionAttr>
<listAttr class="array">
<e type="string">jiang</e>
<e class="array">
<e type="string">one</e>
<e type="string">two</e>
</e>
<e class="object">
<city type="string">Seattle, WA</city>
<street type="string">P.O BOX 54534</street>
<tel type="string">561-832-3180</tel>
<telTwo type="string">531-133-9098</telTwo>
<zip type="number">42452</zip>
</e>
</listAttr>
<nullAttr class="object" null="true"/>
<strArrAttr class="array">
<e type="string">str1</e>
<e type="string">str2</e>
</strArrAttr>
<strAttr type="string">jzj</strAttr>
</root>
*/
System.out.println(write2XML(DocumentHelper.parseText(xmlSerial.write(jsonObj))));
}
private static String write2XML(Document doc) {
ByteArrayOutputStream cache = null;
try {
cache = new ByteArrayOutputStream(1024 * 512);
OutputFormat of = new OutputFormat();
of.setIndent(true);
of.setIndent(" ");
of.setIndentSize(4);
of.setNewlines(true);
BufferedOutputStream bos = new BufferedOutputStream(cache);
XMLWriter xmlWrite = new XMLWriter(bos, of);
xmlWrite.write(doc);
bos.close();
return cache.toString("UTF-8");
} catch (IOException e) {
}
return null;
}
}
- 使用org.json进行转换
package orgjson;
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import junit.framework.TestCase;
import net.sf.json.JSONFunction;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.json.XML;
import bean.Address;
import bean.Bean;
/**
* 使用org.json包进行bean、json、xml的数据转换
* (C) 2009-9-6,jzj
*/
public class JSONFormatTest extends TestCase {
public void testArray2Json() throws JSONException {
JSONArray jsonArr = new JSONArray(new String[][] { { "one", "two" },
{ "three", "four" } });
// print: [["one","two"],["three","four"]]
System.out.println(jsonArr.toString());
//json串转JSONArray
JSONArray jsArr = new JSONArray(jsonArr.toString());
//从JSONObject读取数据
//print: three
System.out.println(((JSONArray) jsArr.get(1)).get(0));
System.out.println("\n");
}
public void testList2Json() throws JSONException {
List list = new ArrayList();
list.add(new Integer(1));
list.add(new Boolean(true));
list.add(new Character('j'));
list.add(new char[] { 'j', 's', 'o', 'n' });
list.add(null);
list.add("json");
list.add(new String[] { "json", "-", "lib" });
list.add(new JSONFunction(new String[] { "i" }, "alert(i)"));
list.add(new Address("P.O BOX 54534", "Seattle, WA", 42452, "561-832-3180",
"531-133-9098"));
//list转JSONArray
JSONArray jsArr = new JSONArray(list);
/*
* list转JSON串
* print:
[
1,
true,
"j",
[
"j",
"s",
"o",
"n"
],
null,
"json",
[
"json",
"-",
"lib"
],
"function(i){ alert(i) }",
"bean.Address@1cf8583"
]
* 注：org.json不支持list中非JSON对象与数组对象外的对象，会直接调用对象的toString方法
*/
System.out.println(jsArr.toString(4));
//从JSON串到JSONArray
JSONArray jsArr1 = new JSONArray(jsArr.toString());
//--从JSONArray里读取
//print: json
System.out.println(((JSONArray) jsArr1.get(6)).get(0));
//不能正确读取对象的信息 print: address.city = bean.Address@1cf8583
System.out.println("address.city = " + jsArr1.get(8));
System.out.println("\n");
}
public void testMap2Json() throws JSONException, DocumentException {
Map map = new LinkedHashMap();
map.put("integer", new Integer(1));
map.put("boolean", new Boolean(true));
map.put("char", new Character('j'));
map.put("charArr", new char[] { 'j', 's', 'o', 'n' });
map.put("null", null);
map.put("str", "json");
map.put("strArr", new String[] { "json", "-", "lib" });
map.put("jsonFunction", new JSONFunction(new String[] { "i" }, "alert(i)"));
map.put("address", new Address("P.O BOX 54534", "Seattle, WA", 42452,
"561-832-3180", "531-133-9098"));
//map转JSONArray
JSONObject jsObj = new JSONObject(map);
/*
* map转JSON串
* print:
{
"address": "bean.Address@1cf8583",
"boolean": true,
"char": "j",
"charArr": [
"j",
"s",
"o",
"n"
],
"integer": 1,
"jsonFunction": "function(i){ alert(i) }",
"null": null,
"str": "json",
"strArr": [
"json",
"-",
"lib"
]
}
*/
System.out.println(jsObj.toString(4));
//从JSON串到JSONObject
jsObj = new JSONObject(jsObj.toString());
//--从JSONObject里读取
//print: json
System.out.println(jsObj.get("str"));
//print: address.city = Seattle, WA
System.out.println("address.city = " + jsObj.get("address"));
//--org.json不支持从JSONObject到Bean的转换
//MorphDynaBean mdBean = (MorphDynaBean) JSONObject.toBean(jsObj);
//--JSONObject转XML
//print:
/*
<root>
<null>null</null>
<char>j</char>
<integer>1</integer>
<address>bean.Address@901887</address>
<strArr>json</strArr>
<strArr>-</strArr>
<strArr>lib</strArr>
<charArr>j</charArr>
<charArr>s</charArr>
<charArr>o</charArr>
<charArr>n</charArr>
<jsonFunction>function(i){ alert(i) }</jsonFunction>
<str>json</str>
<boolean>true</boolean>
</root>
*/
System.out.println(write2XML(DocumentHelper
.parseText(XML.toString(jsObj, "root"))));
System.out.println("\n");
}
/**
* 如果某个Bean里含有Map属性，且Map里存放的为数组，此时需要对Map里的数组进一步用
* JSONArray包装后才能输出正确结果
* @throws JSONException
*/
public void testBeanToJsonStr() throws JSONException {
Bean bean = new Bean();
JSONObject jsonObj = new JSONObject(bean);
try {
/* 如果不用JSONArray进行包装转换，则不能得到正确结果，其关键原因是：如果Bean的某属性
* 所对应的属性类型为Map时，转换Map中的值所对就代码如下：
* } else if (result instanceof Map) {
* map.put(key, new JSONObject((Map)result, includeSuperClass));
* 由于上述代码数组转换成了JSONObject对象了，对应的应该JSONArray
*/
System.out.println(jsonObj.toString(4));
//--以下是正确作法
//得到Bean的Map属性值
Map hashMapAttr = bean.getHashMapAttr();
//对hashMap属性用JSONArray进行包装
Iterator it = hashMapAttr.entrySet().iterator();
//Bean中hashMap属性值转换成map2JsonObj
JSONObject map2JsonObj = new JSONObject();
while (it.hasNext()) {
Map.Entry entry = (Map.Entry) it.next();
map2JsonObj.put((String) entry.getKey(), new JSONArray(entry.getValue()));
}
//置换掉Bean中hashMap属性原有的map对象值，置换后hashMap属性的值为JSONObject对象实例，
//而JSONObject对象实例存储了原hashMap中所对应值的所有信息
jsonObj.put("hashMap", map2JsonObj);
System.out.println(jsonObj.toString(4));
//json转JSONObject
jsonObj = new JSONObject(jsonObj.toString());
//print:Seattle, WA
System.out.println(((JSONObject) ((JSONArray) jsonObj.get("hasSetAttr"))
.get(2)).get("city"));
//--Bean转XML
//print:
System.out.println(XML.toString(jsonObj, "root"));
} catch (JSONException e) {
e.printStackTrace();
}
}
private static String write2XML(Document doc) {
ByteArrayOutputStream cache = null;
try {
cache = new ByteArrayOutputStream(1024 * 512);
OutputFormat of = new OutputFormat();
of.setIndent(true);
of.setIndent(" ");
of.setIndentSize(4);
of.setNewlines(true);
BufferedOutputStream bos = new BufferedOutputStream(cache);
XMLWriter xmlWrite = new XMLWriter(bos, of);
xmlWrite.write(doc);
bos.close();
return cache.toString("UTF-8");
} catch (IOException e) {
}
return null;
}
}
源码请参考《JSON入门与实战详解 —— JavaScript、Java与JSON互转》 附件。
分享到：
发表评论
-
HTML、JS、JSON特殊字符
2010-12-13 23:47 25878JS到HTML特殊字符转换 这几天做项目，发现从服务器端以J ... -
HTML — HTTP URL 中的特殊字符
2009-10-31 18:16 32951. + URL中的+号表示空格 ... -
HTML — CSS选择器
2009-10-25 21:11 2157一个样式规则由两部分组成：选择器和样式声明。选择器表明要为哪一 ... -
部分解决JsUnit无法在firefox3、safari 测试的问题
2009-10-25 07:03 1438在上一篇中出现了一个问题，就是用 jsunit2.2alpha ... -
JsUnit——eclipse插件（四）
2009-10-25 06:59 2445这节我们来看看如何通过JsUnit插件来运行前几节所测试过的测 ... -
10、JavaScript跨浏览器需注意的问题——ajax基础笔记
2009-10-21 22:19 1370向表中追加行 创建表格行时，我们要把创建的 tr 追加到 t ... -
JsUnit详解——Web服务方式（三）
2009-10-21 00:21 2450上两节提到过以Web方式来运行JsUnit，不过不是很详细，这 ... -
JsUnit详解——《ajax基础》笔记（二）
2009-10-20 22:38 2524使用标准/定制查询串 如此说来，测试运行工具是很强大的，但是 ... -
JsUnit详解——《ajax基础》笔记（一）
2009-10-20 19:57 2613JsUnit与JUnit对比 JsUnit也有setUp() ... -
使用Firefox的Web开发插件
2009-10-18 17:53 1473Firefox的Web开发插件为Firefox浏览器增加了大量 ... -
9、访问WEB服务(REST)——ajax基础笔记
2009-10-18 17:24 4022最其名的WEB服务实现是S ... -
8、读取响应头部——ajax基础笔记
2009-10-18 17:20 6753你有时可能需要从服务器获取一些内容，例如，可能想“ping”一 ... -
7、使用JSON向服务器发送数据——ajax基础笔记
2009-10-18 17:20 5212看过前面的例子后（使用XML向服务器发送复杂的数据结构），你可 ... -
6、请求参数作为XML发送——ajax基础笔记
2009-10-18 17:20 1772如果只是使用一个包含 名/值 对的简单查询串，这可能不够健壮， ... -
4、将使用W3C DOM动态生成页面——ajax基础笔记
2009-10-18 17:19 1432使用W3C DOM动态生成页面 dynamicContent ... -
3、将响应解析为XML——ajax基础笔记
2009-10-18 17:18 1062将响应解析为XML parseXML.xml清单： < ... -
2、使用innerHTML属性创建动态内容——ajax基础笔记
2009-10-18 17:17 1923使用innerHTML属性创建动态内容 如果结合作用HTML ... -
1、使用XMLHttpRequest对象——ajax基础笔记
2009-10-18 17:17 2018XMLHttpRequest最早是在 IE5 中以active ... -
30、JavaScript代码优化
2009-10-16 21:25 1566JavaScript代码的速度被分成两部分：下载时间和执行速度 ... -
JavaScript代码优化（二）
2009-10-16 01:32 1196◆字符串的使用 在IE6和IE7中因字符串级联导致的主要问题 ...
相关推荐
要使用 `json-lib` 实现 JSON 与 Java 对象的互转，首先需要在项目中引入该库。如果你使用的是 Maven，可以在 `pom.xml` 文件中添加如下依赖： ```xml <groupId>net.sf.json-lib</groupId> <artifactId>json-lib...
总的来说，这个"（Java）json和String互转必备Jar包"为Java开发者提供了一个便捷的工具，使他们能够在项目中方便地处理JSON数据，无论是从网络获取，还是在本地存储和处理。掌握好这些库的使用，对于提升开发效率和...
它可以方便地将一种类型的数据转换成另一种类型，比如将字符串转成整数，日期转成字符串等，这对于JSON数据处理的灵活性至关重要。 `JsonUtil.java`看起来是一个自定义的工具类，很可能包含了对`json-lib`和`...
java list 转换为json数据java list 转换为json数据java list 转换为json数据java list 转换为json数据java list 转换为json数据java list 转换为json数据java list 转换为json数据java list 转换为json数据java ...
- 数据类型匹配：Java中的数据类型与JSON的类型不一定完全对应，如Java的日期在JSON中通常表示为字符串，需要额外处理。 - JSON的嵌套结构：如果Java对象包含嵌套的对象或数组，转换时要确保这些结构能在JSON中正确...
此外，Echarts是一个基于JavaScript的图表库，它使用JSON数据格式来生成各种图表。在Java后端，我们可以通过上述方式将处理后的数据转换成JSON格式，然后传递给前端的Echarts进行渲染。 总结一下，JSON与Java对象...
JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，被广泛用于前后端交互，而Java作为后端开发的主要语言，常常需要将JSON格式的数据与Java类对象进行相互转换，以便于数据的处理和传输。Jackson库是...
### JSON与Java对象互转：深入理解与实践 在现代软件开发中，JSON（JavaScript Object Notation）作为数据交换的标准格式之一，其轻量级、易于读写的特点使其成为跨平台数据传输的首选。Java作为一种广泛使用的编程...
在Java中，处理JSON数据通常需要借助第三方库，如Jackson、Gson、Fastjson等。本教程将深入探讨JSON与Java之间的数据转换，包括JSON对象到Java对象以及Java对象到JSON对象的转换。 首先，为了进行JSON操作，我们...
总的来说，JSON与Java数据的相互转换是Web开发中的常见任务，理解并熟练掌握这些转换方法对于提升开发效率至关重要。开发者应根据项目需求和团队习惯选择合适的JSON处理库，并确保在处理过程中正确处理可能的异常，...
而Json Schema则是一种JSON格式的规范，用于定义JSON数据的结构和限制。 在Java中，将Bean转换为Json Schema可以帮助我们在服务器端验证客户端发送的数据是否符合预设的模式，避免因数据格式错误导致的问题。这种...
form数据与json对象的互相转换(完整版) * 将web Form 的数据转化成json字符串 * 将json对象的值解析后填入web Form 在AJAX开发中这是关键技术： 1、将form中的数据利用本工具转换成json格式的字符串，再通过ajax传...
附件内容为：Java组装map数据，然后转换为json数据格式；Java解析json数据
而JSON Schema则是一个JSON格式的规范，用于定义JSON数据的结构和限制，类似于XML Schema，它为JSON数据提供了验证规则，确保数据的准确性和一致性。 在JavaScript开发中，有时我们需要将JSON对象转换为JSON Schema...
通过理解和掌握上述知识点，开发者可以有效地在Java对象与JSON之间进行数据转换，从而提升开发效率和代码质量。在实际项目中，根据需求选择适当的序列化和反序列化策略，可以更好地满足业务需求。
java将grib2数据转为json格式，附操作说明,grib2数据文件以及转换后的json文件，数据来源为https://nomads.ncep.noaa.gov/gribfilter.php?ds=gfs_0p25 ECMWF数据由于调整过grib2数据格式，所以不支持解析ECMWF开放...
有了这个工具，你可以快速地将JSON数据映射到Java对象，简化了数据处理的流程。 此外，还可以使用一些流行的Java库，如Gson、Jackson或Fastjson，它们提供了API来实现JSON与Java对象之间的转换。例如，使用Gson库...
在IT行业中，JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，广泛用于服务器与客户端之间传递数据。Java作为一种常用的后端...熟练掌握JSON数据与Java对象之间的转换技巧，对提升开发效率至关重要。
这里我们将深入探讨如何使用Java来获取指定接口的JSON数据，并涉及`HttpServletRquest`类的重要作用。 首先，理解JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，它基于JavaScript的一个子集，...