JSON转换

什么是JSON
•JSON是JavaScript Object Notation的简写，是结构化数据串行化的文本格式
•JSON是一种轻量级的数据交换格式。作为XML的一种替代品，是一种用于客户端与服务器之间进行数据交换的预定义格式
•JSON能够描述四种简单的类型（字符串、数字、布尔值及null）和两种结构化类型（对象及数组）
 JSON语法
•JSON建构于两种结构：
–"名称/值"对的集合。不同的语言中，它被理解为对象，记录，结构，字典，哈希表，有键列表，或者关联数组。
–值的有序列表。在大部分语言中，它被理解为数组。
•JSON对象是一个无序的"名称/值"对的集合。一个对象以"{" （左大括号）开始， "} " （右大括号）结束。每个"名称"后跟一个":" （冒号）； "名称/值"对之间使用", " （逗号）分隔，如：
–var student = {"name" : "zhangsan", "age" : 23, "address" : "changsha"};
•数组是值的有序集合。一个数组以“[”（左中括号）开始，“]”（右中括号）结束。值之间使用“,”（逗号）分隔，如
–var studentList = {"studentArray" :[
            {"name" : "zhangsan", "age" : 23, "address" : "changsha"},
            {"name" : "lisi", "age" : 22, "address" : "changsha"},
            {"name" : "wangwu", "age" : 25, "address" : "changsha"}]};
•名称是一个字符串，值字符串、数值、 ture、false、 null、对象或者数组。这些结构可以嵌套
JSON的对象
•对象是属性、值对的集合。一个对象的开始于"{"，结束于"}"。每一个属性名和值间用":"提示，属性间用","分隔。
JSON的值
•值可以是引号里的字符串、数字、true、false、null，也可以是对象或数组。这些结构都能嵌套。
 
JSON在JS中的用法
•引入json2.js包
–<script type="text/javascript" src="json2.js" ></script>
•将JSON对象转换成字符串：
–var jsonStr = JSON.stringify(jsonObject);
•将字符串转换成JSON对象：
–var jsonObj = JSON.parse(string);
JSON在JAVA中的用法
•导入相关的包
–json-lib-2.2.2-jdk15.jar
–ezmorph-1.0.5.jar
–commons-lang-2.3.jar
–commons-collections-3.2.jar
–commons-beanutils-1.7.0.jar
–commons-logging-1.1.1.jar
•将JSON字符串转换成VO对象：
–JSONObject obj = JSONObject.fromObject(string);
–Employee emp = (Employee) JSONObject.toBean(jsonObj, Employee.class);
•将VO对象转换成JSON字符串：
–JSONObject strJson = JSONObject.fromObject(emp);
–strJson.toString();
•从JSONObject对象中获取数据：
–JSONObject obj = JSONObject.fromObject(string);
–String empName = obj.getString("empName");
–int empNo = obj.getInt("empNo");
–double sal = obj.getDouble("sal");
–long comm = obj.getLong("comm");
•往JSONObject对象中添加数据：
–JSONObject obj = new JSONObject();
–obj.element("empName", "Zhao Yun");
–obj.element("empNo", 1234);
–obj.element("sal", 2500.5D);
–obj.element("comm", 500L);
–obj.element("marriage", false);
–obj.toString();
–boolean marriage = obj.getBoolean(“marriage");




















    /**
     * 
     * 引用的包名：
     *  ezmorph-1.0.6、gson-1.6、json-lib-2.4-jdk15、morph-1.1.1
     * 
     */
//将map转换为json字符串
JSONObject json = new JSONObject(); 
json.putAll(map);
String jString = json.toString().replaceAll("\"", "'");

    /**
     * 
     * 函数名称: parseData
     * 函数描述: 将json字符串转换为map
     * @param data
     * @return
     */
    public static Map<String, String> parseData(String data){
        GsonBuilder gb = new GsonBuilder();
        Gson g = gb.create();
        Map<String, String> map = g.fromJson(data, new TypeToken<Map<String, String>>() {}.getType()); 
        return map;
    }






     JSON是一种轻量级的数据交换格式，在现在的web开发中，是非常常见的。在没有方便的工具之前，我们或许会使用拼字符串的形式来生成json数组，今天我们使用一个json-lib.jar包来为我们实现生成json的功能。
所必须的包有：
commons-httpclient-3.1.jar


commons-lang-2.4.jar


commons-logging-1.1.1.jar


json-lib-2.4-jdk15.jar


ezmorph-1.0.6.jar


commons-collections-3.2.1.jar

1、bean转为Json
User u = new User();
u.setAge(22);
u.setUsername("hzucmj");
u.setEnabled(true);
 
JSONObject json = JSONObject.fromObject(u);
System.out.println(json.toString()); //结果为：{"enabled":true,"username":"hzucmj","age":22}
2、List转为Json
User u1 = new User();
u1.setAge(22);
u1.setUsername("hzucmj");
u1.setEnabled(true);
 
User u2 = new User();
u2.setAge(20);
u2.setUsername("ctf");
u2.setEnabled(true);
 
List<Object> list = new ArrayList<Object>();
list.add(u1);</p>
list.add(u2);</p>
 
JSONArray json = JSONArray.fromObject(list);
System.out.println(json.toString()); //结果为：[{"enabled":false,"username":"ctf","age":20},{"enabled":false,"username":"","age":0}]
3、Map转为Json
HashMap<String, Comparable> map = new HashMap<String, Comparable>();
map.put("name", "hzucmj");
map.put("age", 22);
JSONObject json = JSONObject.fromObject(list);
System.out.println(json.toString()); //结果为：{"name":"hzucmj","age":22}
4. JSON数据对象格式转换为JAVA类型的Beans
示例1(转换为动态的bean)：
String json = "{name=\"json\",bool:true,int:1,double:2.2,func:function(a){ return a; },array:[1,2]}";
JSONObject jsonObject = JSONObject.fromObject(json);
Object bean = 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"));
输出：junit测试显示为绿条，即值相等。
示例2(转换为具体的bean)：
String json = "{bool:true,integer:1,string:\"json\"}";
JSONObject jsonObject = JSONObject.fromObject(json);
BeanA bean = (BeanA) JSONObject.toBean(jsonObject, BeanA.class);
assertEquals(jsonObject.get("bool"), Boolean.valueOf(bean.isBool()));
assertEquals(jsonObject.get("integer"), new Integer(bean.getInteger()));
assertEquals(jsonObject.get("string"), bean.getString());
注：BeanA是具体相关属性的getters & setters方法的具体javaBean
5.Java-Json相互转换过滤器--把java类型转换为json时属性的过滤，下面我们再以3中的实例1来做个演示：
实例1：
Map map = new HashMap();
map.put("name", "json");
map.put("bool", Boolean.TRUE);
map.put("int", new Integer(1));
map.put("arr", new String[] { "a", "b" });
map.put("func", "function(i){ return this.arr[i]; }");
JsonConfig jsonConfig = new JsonConfig();
jsonConfig.setJsonPropertyFilter(new PropertyFilter() {
public boolean apply(Object source, String name, Object value) {
if (value != null && Number.class.isAssignableFrom(value.getClass())) {
return true;
}
return false;
}
});
JSONObject json = JSONObject.fromObject(map, jsonConfig);
System.out.println(json);
输出：{"func":function(i){ return this.arr[i]; },"arr":["a","b"],"bool":true,"name":"json"}
和上面的输出：{"func":function(i){ return this.arr[i]; },"arr":["a","b"],"int":1,"bool":true,"name":"json"}
它少了："int":1,这段，这就是属性过滤器发挥了作用，看代码就可以知道它把值为Number型的都给过滤掉了。
实例2：
如果我们把上例中的Number.class.isAssignableFrom(value.getClass())中的Number改为String呢？
Map map = new HashMap();
map.put("name", "json");
map.put("bool", Boolean.TRUE);
map.put("int", new Integer(1));
map.put("arr", new String[] { "a", "b" });
map.put("func", "function(i){ return this.arr[i]; }");
JsonConfig jsonConfig = new JsonConfig();
jsonConfig.setJsonPropertyFilter(new PropertyFilter() {
public boolean apply(Object source, String name, Object value) {
if (value != null && String.class.isAssignableFrom(value.getClass())) //这里是过滤的关键
{
return true;
}
return false;
}
});
JSONObject json = JSONObject.fromObject(map, jsonConfig);
System.out.println(json);
输出：{"arr":["a","b"],"int":1,"bool":true}//它把Value的类型为String的都给过滤掉了。
6.Json-Java相互转换过滤器--同5相反这次--把json-转换为java时属性的过滤，下面我们以4中的实例1来做个演示：
实例1：
String json = "{name=\"json\",bool:true,int:1,double:2.2,func:function(a){ return a; },array:[1,2]}";
JSONObject jsonObject = JSONObject.fromObject(json);
JsonConfig jsonConfig = new JsonConfig();
jsonConfig.setRootClass(Map.class);
jsonConfig.setJavaPropertyFilter(new PropertyFilter() {
public boolean apply(Object source, String name, Object value) {
if ("bool".equals(name) || "double".equals(name)) //这里是过滤的关键
{
return true;
}
return false;
}
});
Object bean = JSONObject.toBean(jsonObject, jsonConfig);
System.out.println(bean);
输出：{func=function(a){ return a; }, int=1, name=json, array=[1, 2]}
同4中的实例1输出：{double=2.2, func=function(a){ return a; }, int=1, name=json, bool=true, array=[1, 2]}
少了：double=2.2, bool=true,因为name为bool和double的项已经被过滤掉了。
实例2：
String json = "{name=\"json\",bool:true,int:1,double:2.2,func:function(a){ return a; },array:[1,2]}";
JSONObject jsonObject = JSONObject.fromObject(json);
JsonConfig jsonConfig = new JsonConfig();
jsonConfig.setRootClass(Map.class);
jsonConfig.setJavaPropertyFilter(new PropertyFilter() {
public boolean apply(Object source, String name, Object value) {
if (value != null && String.class.isAssignableFrom(value.getClass())) // 这里是过滤的关键
{
return true;
}
return false;
}
});
Object bean = JSONObject.toBean(jsonObject, jsonConfig);
System.out.println(bean);
输出：{double=2.2, func=function(a){ return a; }, int=1, bool=true, array=[1, 2]}
由此可见，无论是java转换为json还是json转换为java，过滤器都可以根据name和value来过滤。
通过json-lib提供给我们的方法，实现json数组的生成就变得很简单了，当然，json-lib提供的也不仅仅是这些方法而已，还有其它一些方法大家可以好好研究研究啊。
























基于json-lib.jar包 创建JSONArray的四个常用方法
1.从头或者从零开始，创建一个JSONArray(Creating a JSONArray from scratch)
实例1： 
JSONArray jsonArray = new JSONArray().element("JSON").element("1").element("2.0").element("true");
assertEquals("JSON", jsonArray.getString(0));
assertEquals(1, jsonArray.getInt(1));
assertEquals(2.0d, jsonArray.getDouble(2), 0d);
assertTrue(jsonArray.getBoolean(3));

2.使用一个JSON格式化字符串来创建一个JSONArray(Creating a JSONArray from a JSON formatted string)  
实例1：
String str = "['JSON', 1, 2.0, true]";   //注意该字符串的格式"[ , ]"
JSONArray jsonArray = (JSONArray) JSONSerializer.toJSON( str );   
assertEquals( "JSON", jsonArray.getString(0) );         
assertEquals( 1, jsonArray.getInt(1) );         
assertEquals( 2.0d, jsonArray.getDouble(2), 0d );         
assertTrue( jsonArray.getBoolean(3) ); 
3.使用一个Collection来创建一个JSONArray(Creating a JSONArray from a Collection)
实例1：
List list = new ArrayList();   
list.add( "JSON" );   
list.add( "1" );   
list.add( "2.0" );   
list.add( "true" );   
JSONArray jsonArray = (JSONArray) JSONSerializer.toJSON( list );   
assertEquals( "JSON", jsonArray.getString(0) );         
assertEquals( 1, jsonArray.getInt(1) );         
assertEquals( 2.0d, jsonArray.getDouble(2), 0d );         
assertTrue( jsonArray.getBoolean(3) ); 
4.使用一个Array来创建一个JSONArray(Creating a JSONArray from an array)
实例1：
Object[] array = new Object[] { "JSON", 1, 2.0, true };
JSONArray jsonArray = (JSONArray) JSONSerializer.toJSON(array);
assertEquals("JSON", jsonArray.getString(0));
assertEquals(1, jsonArray.getInt(1));
assertEquals(2.0d, jsonArray.getDouble(2), 0d);
assertTrue(jsonArray.getBoolean(3));
实例2：
Object[] array = new Object[] { "JSON", 1, 2.0, true };
JSONArray jsonArray = JSONArray.fromObject(array);
assertEquals("JSON", jsonArray.getString(0));
assertEquals(1, jsonArray.getInt(1));
assertEquals(2.0d, jsonArray.getDouble(2), 0d);
assertTrue(jsonArray.getBoolean(3));
实例3：
boolean[] boolArray = new boolean[] { true, false, true };
JSONArray jsonArray = JSONArray.fromObject(boolArray);
System.out.println(jsonArray);
输出：[true,false,true]


由此可见，无论要转换的源是哪种类型，都可以使用(JSONArray) JSONSerializer.toJSON()或JSONArray.fromObject()来转换;