钱柜999:实习小结,json的使用小结

钱柜999:实习小结,json的使用小结

轻量级的依据文本的沟通格式

json小结,实习小结

JSON的用处   使用基于JavaScript的应用程序,在那之中饱含浏览器扩充和网站  使用JSON格式系列化和结构化的多寡传输网络连接
  那至关主要用以服务器和Web应用程序之间的数量传输
  Web服务和API选拔JSON格式提供公共数据   它能够用来与今世编制程序语言
JSON的特点   易于读写JSON   轻量级的基于文本的置换格式   独立语言
JSON格式示例:

  • 名称/值对数据表示
  • 大括号持有的对象和种种名称后跟”:”(冒号),名称/值对的分别,(逗号)
  • 方括号具有数组和值,(逗号)分隔。

 1 {
 2     "book": [
 3     {
 4        "id":"01",
 5        "language": "Java",
 6        "edition": "third",
 7        "author": "Herbert Schildt"
 8     },
 9     {
10        "id":"07",
11        "language": "C++",
12        "edition": "second"
13        "author": "E.Balagurusamy"
14     }]
15 }

 JSON帮衬的数据类型: 

  类型                          描述

*     Number             在JavaScript中的双精度浮点格式
     String       双引号的反斜杠转义的Unicode
  Boolean      true 或 false
  Array       值的雷打不动类别
  Value
      它能够是贰个字符串,二个数字,真的依然假(true/false),空(null
)等
  Object      冬辰集聚键值对
  Whitespace    能够动用任何一对中的令牌
  null        empty*

<script language="javascript" >

  var JSONObj = { "Pascal" : [ 
      { "Name"  : "Pascal Made Simple", "price" : 700,"category":[p1,p2] },
      { "Name"  : "Guide to Pascal", "price" : 400,"category":[p1,p2] }
   ],                       
   "Scala"  : [
      { "Name"  : "Scala for the Impatient", "price" : 1000 ,"category":[p1,p2]}, 
      { "Name"  : "Scala in Depth", "price" : 1300,"category":[p1,p2] }
   ]};
</script>

  jquery协助的将字符串转Json对象方法:

    第一种方法:

function strToJson(str){    
     var json = eval('(' + str + ')');    
     return json;    
}  

    第二种格局:使用JSON.parse需严谨依据JSON标准,如属性都需用引号引起来,未有用引号引起来用JSON.parse全部浏览器中均抛非常,分析退步。

function strToJson(str){  
    return JSON.parse(str);  
}  

    第两种方法:

 function strToJson(str){  
    var jsonObj = $.parseJSON(JSONObj);
    return jsonObj ;  
}  

  

JSON的用途
使用基于JavaScript的应用程序,在那之中包罗浏览器增加和网站使用JSON格式体系化和结构化的数目传输互联网连接…

  用jackson转换java类与json的JsonUtils类:

您恐怕感兴趣的稿子:

  • 浅析JSONP本事原理及贯彻
  • JSONP原理及简便达成

    第一种办法:

如上那篇json的施用小结正是作者分享给我们的全体内容了,希望能给我们多少个参阅,也希望我们多多协理脚本之家。

  Web服务和API选拔JSON格式提供公共数据

那至关心重视要用于服务器和Web应用程序之间的数量传输

import org.codehaus.jackson.map.ObjectMapper;

public class JsonUtils {

    static ObjectMapper objectMapper;
    /**
     * 使用泛型方法,把json字符串转换为相应的JavaBean对象。
     * 转换为普通JavaBean:readValue(json,Student.class)
     * 转换为List:readValue(json,List.class
     * ).但是如果我们想把json转换为特定类型的List,比如List<Student>,就不能直接进行转换了。
     * 因为readValue(json,List
     * .class)返回其实是List<Map>类型,你不能指定readValue()的第二个参数是List<Student
     * >.class,所以不能直接转换。
     * 我们可以把readValue()的第二个参数传递为Student[].class.然后使用Arrays.asList
     * ();方法把得到的数组转换为特定类型的List。 转换为Map:readValue(json,Map.class) 我们使用泛型,得到的也是泛型
     * 
     * @param content
     *            要转换的JavaBean类型
     * @param valueType
     *            原始json字符串数据
     * @return JavaBean对象
     */
    public static <T> T readValue(String content, Class<T> valueType) {
        if (objectMapper == null) {
            objectMapper = new ObjectMapper();
        }
        try {
            return objectMapper.readValue(content, valueType);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }

    /**
     * 把JavaBean转换为json字符串 普通对象转换:toJson(Student) List转换:toJson(List)
     * Map转换:toJson(Map) 我们发现不管什么类型,都可以直接传入这个方法
     * 
     * @param object
     *            JavaBean对象
     * @return json字符串
     */
    public static String toJSon(Object object) {
        if (objectMapper == null) {
            objectMapper = new ObjectMapper();
        }
        try {
            return objectMapper.writeValueAsString(object);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }
}

轻易读写JSON

  使用基于JavaScript的应用程序,在这之中囊括浏览器扩展和网址

采取JSON格式类别化和结构化的数量传输互联网连接

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.log4j.Logger;

public class Log4jTest {

    private static final Logger logger = Logger.getLogger(Log4jTest.class);

    public static void main(String[] args) {
        try {
            List<Student> list = new ArrayList<Student>();
            Student s = new Student();
            s.setName("小明");
            s.setAge(11);
            Student s2 = new Student();
            s2.setName("小红");
            s2.setAge(22);
            list.add(s);
            list.add(s2);

            Map<String , String> map = new HashMap<String , String>();
            map.put("1", "a");
            map.put("2", "b");
            map.put("3", "c");
            /**
             * 使用jackson转换javaBean,list,map为json字符串
             */
            System.out.println(JsonUtils.toJSon(s));
            System.out.println(JsonUtils.toJSon(list));
            System.out.println(JsonUtils.toJSon(map));

            String strJson = "{\"name\":\"小明\",\"age\":11}";
            Student student = JsonUtils.readValue(strJson, Student.class);
            System.out.println(student.getName()+student.getAge());

            System.out.println("****将Json字符串转换为List集合************");
            String strJson1 = "[{\"name\":\"小明\",\"age\":\"11\"},{\"name\":\"小明\",\"age\":\"11\"}]";
            System.out.println(JsonUtils.readValue(strJson1, List.class));

            System.out.println("****将Json字符串转换为javaBean数组************");
            String strJsonArr = "[{\"name\":\"小明\",\"age\":11},{\"name\":\"小明\",\"age\":11},{\"name\":\"小明\",\"age\":11}]";
            Student[] studentArr = JsonUtils.readValue(strJsonArr, Student[].class);
            for (Student student2 : studentArr) {
                System.out.println(student2.getAge());
            }

            System.out.println("****将Json字符串转换为Map集合************");
            String strJsonMap = "{\"one\":{\"name\":\"小明\",\"age\":11},\"two\":{\"name\":\"小明\",\"age\":11},\"three\":{\"name\":\"小明\",\"age\":11}}";
            Map<String,Map<String,Object>> jsonMap = JsonUtils.readValue(strJsonMap, Map.class);
            System.out.println(jsonMap);
        } catch (Exception e) {
            logger.error("This is debug message.",e);
        }
    }
}

•大括号持有的靶子和各样名称后跟”:”(冒号),名称/值对的握别,(逗号)

  易于读写JSON

它能够用来与今世编制程序语言

  使用JSON格式系列化和结构化的多少传输网络连接

JSON扶助的数据类型: 

  string     java.lang.String

JSON的用途

import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class JsonUtil {

    /**
     * 序列化对象为JSON格式 遵循JSON组织公布标准
     * 
     * @date 2008/05/07
     * @version 1.0.0
     */
    /** Commons Logging instance. */
    private static org.apache.commons.logging.Log log = org.apache.commons.logging.LogFactory
            .getLog(JsonUtil.class);

    /**
     * @param obj
     *            任意对象
     * @return String
     */
    public static String object2json(Object obj) {
        StringBuilder json = new StringBuilder();
        if (obj == null) {
            json.append("\"\"");
        } else if (obj instanceof String
                || obj instanceof Integer
                || obj instanceof Boolean
                || obj instanceof Double
                || obj instanceof Long 
                || obj instanceof Float 
                || obj instanceof Integer 
                || obj instanceof Character 
                || obj instanceof Byte 
        ) {
            json.append("\"").append(string2json(obj.toString())).append("\"");
        } else if (obj instanceof Object[]) {
            json.append(array2json((Object[]) obj));
        } else if (obj instanceof List) {
            json.append(list2json((List<?>) obj));
        } else if (obj instanceof Map) {
            json.append(map2json((Map<?, ?>) obj));
        } else if (obj instanceof Set) {
            json.append(set2json((Set<?>) obj));
        }else if (obj instanceof Date) {
            Date date =(Date) obj;
            SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            json.append("\"").append(sdf.format(date)).append("\"");
        } else {
            json.append(bean2json(obj));
        }
        return json.toString();
    }

    /**
     * @param bean
     *            bean对象
     * @return String
     */
    public static String bean2json(Object bean) {
        StringBuilder json = new StringBuilder();
        json.append("{");
        PropertyDescriptor[] props = null;
        try {
            props = Introspector.getBeanInfo(bean.getClass(), Object.class)
                    .getPropertyDescriptors();
        } catch (IntrospectionException e) {
        }
        if (props != null) {
            for (int i = 0; i < props.length; i++) {
                try {
                    String name = object2json(props[i].getName());
                    String value = object2json(props[i].getReadMethod().invoke(
                            bean));
                    json.append(name);
                    json.append(":");
                    json.append(value);
                    json.append(",");
                } catch (Exception e) {
                    log.error(e);
                }
            }
            json.setCharAt(json.length() - 1, '}');
        } else {
            json.append("}");
        }
        return json.toString();
    }

    /**
     * @param list
     *            list对象
     * @return String
     */
    public static String list2json(List<?> list) {
        StringBuilder json = new StringBuilder();
        json.append("[");
        if (list != null && list.size() > 0) {
            for (Object obj : list) {
                json.append(object2json(obj));
                json.append(",");
            }
            json.setCharAt(json.length() - 1, ']');
        } else {
            json.append("]");
        }
        return json.toString();
    }

    /**
     * @param array
     *            对象数组
     * @return String
     */
    public static String array2json(Object[] array) {
        StringBuilder json = new StringBuilder();
        json.append("[");
        if (array != null && array.length > 0) {
            for (Object obj : array) {
                json.append(object2json(obj));
                json.append(",");
            }
            json.setCharAt(json.length() - 1, ']');
        } else {
            json.append("]");
        }
        return json.toString();
    }

    /**
     * @param map
     *            map对象
     * @return String
     */
    public static String map2json(Map<?, ?> map) {
        StringBuilder json = new StringBuilder();
        json.append("{");
        if (map != null && map.size() > 0) {
            for (Object key : map.keySet()) {
                json.append(object2json(key));
                json.append(":");
                json.append(object2json(map.get(key)));
                json.append(",");
            }
            json.setCharAt(json.length() - 1, '}');
        } else {
            json.append("}");
        }
        return json.toString();
    }

    /**
     * @param set
     *            集合对象
     * @return String
     */
    public static String set2json(Set<?> set) {
        StringBuilder json = new StringBuilder();
        json.append("[");
        if (set != null && set.size() > 0) {
            for (Object obj : set) {
                json.append(object2json(obj));
                json.append(",");
            }
            json.setCharAt(json.length() - 1, ']');
        } else {
            json.append("]");
        }
        return json.toString();
    }

    /**
     * @param s
     *            参数
     * @return String
     */
    public static String string2json(String s) {
        if (s == null)
            return "";
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            switch (ch) {
            case '"':
                sb.append("\\\"");
                break;
            case '\\':
                sb.append("\\\\");
                break;
            case '\b':
                sb.append("\\b");
                break;
            case '\f':
                sb.append("\\f");
                break;
            case '\n':
                sb.append("\\n");
                break;
            case '\r':
                sb.append("\\r");
                break;
            case '\t':
                sb.append("\\t");
                break;
            case '/':
                sb.append("\\/");
                break;
            default:
                if (ch >= '\u0000' && ch <= '\u001F') {
                    String ss = Integer.toHexString(ch);
                    sb.append("\\u");
                    for (int k = 0; k < 4 - ss.length(); k++) {
                        sb.append('0');
                    }
                    sb.append(ss.toUpperCase());
                } else {
                    sb.append(ch);
                }
            }
        }
        return sb.toString();
    }
}

JSON格式示例:

function strToJson(str){    
     var json = eval('(' + str + ')');    
     return json;    
}  

Web服务和API选拔JSON格式提供公共数据

  • 名称/值对数据表示
  • 大括号持有的靶子和每一个名称后跟”:”(冒号),名称/值对的拜别,(逗号)
  • 方括号具有数组和值,(逗号)分隔。

    1 {
    2 “book”: [
    3 {
    4 “id”:”01″,
    5 “language”: “Java”,
    6 “edition”: “third”,
    7 “author”: “Herbert Schildt”
    8 },
    9 {
    10 “id”:”07″,
    11 “language”: “C++”,
    12 “edition”: “second”
    13 “author”: “E.Balagurusamy”
    14 }]
    15 }

选用基于JavaScript的应用程序,其中囊括浏览器扩充和网址

  JSON      Java

JSON的特点

<script language="javascript" >

  var JSONObj = { "Pascal" : [ 
      { "Name"  : "Pascal Made Simple", "price" : 700,"category":[p1,p2] },
      { "Name"  : "Guide to Pascal", "price" : 400,"category":[p1,p2] }
   ],                       
   "Scala"  : [
      { "Name"  : "Scala for the Impatient", "price" : 1000 ,"category":[p1,p2]}, 
      { "Name"  : "Scala in Depth", "price" : 1300,"category":[p1,p2] }
   ]};
</script>

•方括号具有数组和值,(逗号)分隔。

  类型                          描述

admin

网站地图xml地图