【学习】006数据交换格式与SpringIOC底层实现

课程目标

XML和JSON

Java反射机制

手写SpringIOC

什么是数据交换格式

客户端与服务器常用数据交换格式xml、json、html

数据交换格式用场景

移动端(安卓、IOS)通讯方式采用http协议+JSON格式 走restful风格。

很多互联网项目都采用Http协议+JSON

因为xml比较重WebService服务采用http+xml格式 银行项目使用比较多

数据交换格式

JSON简单使用

什么是JSON

JSON(JavaScript Object Notation)是一种轻量级的数据交换格式，相比于xml这种数据交换格式来说，因为解析xml比较的复杂，而且需要编写大段的代码，所以客户端和服务器的数据交换格式往往通过JSON来进行交换。

样例:

{
    "id": "10",
    "name": " 洪墨水",
    "items": [
        {
            "itemId": "20",
            "itemName": "JSON"
        },
        {
            "itemId": "21",
            "itemName": "XML"
        }
    ]
}

JSON：JavaScript 对象表示法（JavaScript Object Notation）。

JSON的形式是用大括号“{}”包围起来的项目列表，每一个项目间用逗号（,）分隔，而项目就是用冒号（:）分隔的属性名和属性值。这是典型的字典表示形式，也再次表明javascript里的对象就是字典结构。不管多么复杂的对象，都可以用一句JSON代码来创建并赋值。在JSON中，名称 / 值对包括字段名称（在双引号中），后面写一个冒号，然后是值。

SON格式的分类

JSON有两种结构

json简单说就是javascript中的对象和数组，所以这两种结构就是对象和数组两种结构，通过这两种结构可以表示各种复杂的结构

1、对象：对象在js中表示为“{}”括起来的内容，数据结构为 {key：value,key：value,...}的键值对的结构，在面向对象的语言中，key为对象的属性，value为对应的属性值，所以很容易理解，取值方法为对象.key 获取属性值，这个属性值的类型可以是数字、字符串、数组、对象几种。

2、数组：数组在js中是中括号“[]”括起来的内容，数据结构为 ["java","javascript","vb",...]，取值方式和所有语言中一样，使用索引获取，字段值的类型可以是数字、字符串、数组、对象几种。
经过对象、数组2种结构就可以组合成复杂的数据结构了。

常用JSON解析框架

fastjson(阿里)、gson(谷歌)、jackson(SpringMVC自带)

使用fastjson解析json

添加jar fastjson-1.1.43 或引入maven依赖

<dependency>
　　<groupId>com.alibaba</groupId>
　　<artifactId>fastjson</artifactId>
　　<version>1.1.43</version>
</dependency>

使用fastjson api

　　 // 把JSON文本parse为JSONObject或者JSONArray
    public static final Object parse(String text);

    // 把JSON文本parse成JSONObject
    public static final JSONObject parseObject(String text);

    // 把JSON文本parse为JavaBean
    public static final <T> T parseObject(String text, Class<T> clazz);

    // 把JSON文本parse成JSONArray
    public static final JSONArray parseArray(String text);

    // 把JSON文本parse成JavaBean集合
    public static final <T> List<T> parseArray(String text, Class<T> clazz);

    // 将JavaBean序列化为JSON文本
    public static final String toJSONString(Object object);

    // 将JavaBean序列化为带格式的JSON文本
    public static final String toJSONString(Object object, boolean prettyFormat);

    // 将JavaBean转换为JSONObject或者JSONArray
    public static final Object toJSON(Object javaObject);

解析json

static String jsonStr = "{\"id\": \"10\",\"name\": \" 洪墨水\",\"items\": [{\"itemId\": \"20\",\"itemName\": \"JSON\"},{\"itemId\": \"21\",\"itemName\": \"XML\"}]}";

    public static void main(String[] args)
    {
        JSONObject jsonObject = new JSONObject();
        // 将json字符串转为jsonObject
        JSONObject jsonStrObject = jsonObject.parseObject(jsonStr);
        JSONArray jsonArray = jsonStrObject.getJSONArray("items");
        for (Object object : jsonArray)
        {
            JSONObject stObject = (JSONObject) object;
            String itemId = stObject.getString("itemId");
            String itemName = stObject.getString("itemName");
            System.out.println(itemId + ":" + itemName);
        }
    }

Json转对象

定义类

package com.hongmoshui.entity;

public class Item
{
    private String itemId;

    private String itemName;

    public String getItemId()
    {

        return itemId;
    }

    public void setItemId(String itemId)
    {

        this.itemId = itemId;
    }

    public String getItemName()
    {

        return itemName;
    }

    public void setItemName(String itemName)
    {

        this.itemName = itemName;
    }

    @Override
    public String toString()
    {
        return "Item [itemId=" + itemId + ", itemName=" + itemName + "]";
    }

}
package com.hongmoshui.entity;

import java.util.List;

public class User extends Object
{

    private String id;

    private String name;

    private List<Item> items;

    public User(String id)
    {
        System.out.println("我是通过有参构造函数初始化 id:" + id);
        this.id = id;
    }

    public User()
    {
        System.out.println("我是无参数构造函数初始化");
    }

    public String getId()
    {

        return id;
    }

    public void setId(String id)
    {

        this.id = id;
    }

    public String getName()
    {

        return name;
    }

    public void setName(String name)
    {

        this.name = name;
    }

    public List<Item> getItems()
    {

        return items;
    }

    public void setItems(List<Item> items)
    {

        this.items = items;
    }

    @Override
    public String toString()
    {
        return "User [id=" + id + ", name=" + name + ", items=" + items + "]";
    }

}

Json转换对象api

        // 2.使用java反射机制 对应生成对象
        User user = new JSONObject().parseObject(json, User.class);
        System.out.println("user:" + user.toString());

组装json

Json api封装json

        // 1.json api 封装json
        JSONObject root = new JSONObject();
        root.put("id", "01");
        root.put("name", "张三");
        JSONArray arrayList = new JSONArray();
        JSONObject object1 = new JSONObject();
        object1.put("itemId", "20");
        object1.put("itemName", "JSON");
        JSONObject object2 = new JSONObject();
        object2.put("itemId", "30");
        object2.put("itemName", "Object");
        arrayList.add(object1);
        arrayList.add(object2);
        root.put("items", arrayList);
        System.out.println(root.toJSONString());

将对象转换成json字符串

　　　　 User user = new User();
        user.setId("01");
        user.setName("张三");
        List<Item> items = new ArrayList<Item>();
        Item item1 = new Item();
        item1.setItemId("20");
        item1.setItemName("JSON");
        Item item2 = new Item();
        item2.setItemId("30");
        item2.setItemName("Object");
        items.add(item1);
        items.add(item2);
        user.setItems(items);
        System.out.println(new JSONObject().toJSONString(user));

XML简单使用

什么是XML？

它是可扩展标记语言（Extensible Markup Language，简称XML），是一种标记语言。

XML 全称为可扩展的标记语言。主要用于描述数据和用作配置文件。

XML 文档在逻辑上主要由一下 5 个部分组成：

XML 声明：指明所用 XML 的版本、文档的编码、文档的独立性信息

文档类型声明：指出 XML 文档所用的 DTD

元素：由开始标签、元素内容和结束标签构成

注释：以结束，用于对文档中的内容起一个说明作用

处理指令：通过处理指令来通知其他应用程序来处理非 XML 格式的数据，格式为

　　XML 文档的根元素被称为文档元素，它和在其外部出现的处理指令、注释等作为文档实体的子节点，根元素本身和其内部的子元素也是一棵树。

XML样例

<?xml version="1.0" encoding="UTF-8"?>
<students>
    <student1 id="001">
        <微信公众号>洪墨水001</微信公众号>
        <学号>20140101</学号>
        <地址>广东省深圳</地址>
        <座右铭>要么强大，要么听话</座右铭>
    </student1>
    <student2 id="002">
        <新浪微博>洪墨水002</新浪微博>
        <学号>20140102</学号>
        <地址>广东省广州</地址>
        <座右铭>在哭泣中学会坚强</座右铭>
    </student2>
</students>

<?xml version="1.0" encoding="UTF-8"?>作用：xml文件头部要写的话，说明了xml的版本和编码，utf-8一般是网络传输用的编码

XML解析方式？

Dom4j、Sax、Pull

Dom4j与Sax区别

dom4j不适合大文件的解析，因为它是一下子将文件加载到内存中，所以有可能出现内存溢出，sax是基于事件来对xml进行解析的，所以他可以解析大文件的xml，也正是因为如此，所以dom4j可以对xml进行灵活的增删改查和导航，而sax没有这么强的灵活性，所以sax经常是用来解析大型xml文件，而要对xml文件进行一些灵活（crud）操作就用dom4j。

使用dom4j解析xml

解析XML过程是通过获取Document对象，然后继续获取各个节点以及属性等操作，因此获取Document对象是第一步，大体说来，有三种方式：

1.自己创建Document对象

Document document = DocumentHelper.createDocument();
Element root = document.addElement("students");

其中students是根节点，可以继续添加其他节点等操作。

2.读取XML文本内容获取Document对象

// 创建SAXReader对象
SAXReader reader = new SAXReader();
// 读取文件 转换成Document
Document document = reader.read(new File("XXXX.xml"));

3.String类型的内容转换成Document对象

String xmlStr = "<students>......</students>";
Document document = DocumentHelper.parseText(xmlStr);

解析xml代码

Xml配置:

<?xml version="1.0" encoding="UTF-8"?>
<students>
    <student1 id="001">
        <微信公众号>洪墨水001</微信公众号>
        <学号>20140101</学号>
        <地址>广东省深圳</地址>
        <座右铭>要么强大，要么听话</座右铭>
    </student1>
    <student2 id="002">
        <新浪微博>洪墨水002</新浪微博>
        <学号>20140102</学号>
        <地址>广东省广州</地址>
        <座右铭>在哭泣中学会坚强</座右铭>
    </student2>
</students>

Java代码：

package com.hongmoshui;

import java.io.File;
import java.util.Iterator;
import java.util.List;

import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

public class Text
{
    public static void main(String[] args) throws DocumentException
    {
        SAXReader saxReader = new SAXReader();
        Document read = saxReader.read(new File(ClassLoader.getSystemResource("stu.xml").getPath()));
        // 获取根节点
        Element rootElement = read.getRootElement();
        getNodes(rootElement);

    }

    /**
     * 读取节点信息
     * @param rootElement 根节点
     * @author 墨水
     */
    static public void getNodes(Element rootElement)
    {
        System.out.println("当前节点名称:" + rootElement.getName());
        // 获取属性ID
        List<Attribute> attributes = rootElement.attributes();
        for (Attribute attribute : attributes)
        {
            System.out.println("属性:" + attribute.getName() + "---" + attribute.getText());
        }
        if (!rootElement.getTextTrim().equals(""))
        {
            System.out.println(rootElement.getName() + "--" + rootElement.getText());
        }
        // 使用迭代器遍历
        Iterator<Element> elementIterator = rootElement.elementIterator();
        while (elementIterator.hasNext())
        {
            Element next = elementIterator.next();
            getNodes(next);
        }

    }

}

注意:

 ClassLoader().getSystemResource("stu.xml").getPath() 获取当前项目路径中的stu.xml文件的路径

XML与JSON区别

Xml是重量级数据交换格式，占宽带比较大。

JSON是轻量级交换格式，xml占宽带小。

所有很多互联网公司都会使用json作为数据交换格式

很多银行项目，大多数还是在使用xml。

Java反射机制

什么是Java反射

就是正在运行，动态获取这个类的所有信息。

反射机制的作用

1，反编译：.class-->.java

2．通过反射机制访问java对象的属性，方法，构造方法等；

反射机制的应用场景

Jdbc 加载驱动-----

Spring ioc

框架

反射机制获取类有三种方法

        // 第一种方式：
        Class c1 = Class.forName("User");

        // 第二种方式：java中每个类型都有class 属性.
        Class c2 = User.class;

        // 第三种方式： java语言中任何一个java对象都有getClass方法
        User user = new User();

        // c3是运行时类(e的运行时类是User)
        Class c3 = user.getClass();

反射创建对象的方式

        // 创建此Class 对象所表示的类的一个新实例
        Class<?> forName = Class.forName("com.hongmoshui.entity.User");
        // 调用了User的无参数构造方法.
        Object objectInstance = forName.newInstance();
        System.out.println(objectInstance.toString());
        // 调用了User的有参数构造方法.
        Constructor<?> constructor = forName.getConstructor(String.class);
        User userInstance = (User) constructor.newInstance("123");
        System.out.println(userInstance.toString());

反射创建api


方法名称
作用

getDeclaredMethods []
获取该类的所有方法

getReturnType()
获取该类的返回值

getParameterTypes()
获取传入参数

getDeclaredFields()
获取该类的所有字段

setAccessible
允许访问私有成员

使用反射为类私有属性赋值

        // 为user对象私有属性赋值
        Class<?> classUser = Class.forName("com.hongmoshui.entity.User");
        // 获取到当前的所有属性
        Field[] fields = classUser.getDeclaredFields();
        for (Field field : fields)
        {
            System.out.println("属性:" + field.getName());
        }
        // 获取当前所有的方法
        Method[] declaredMethods = classUser.getDeclaredMethods();
        for (Method method : declaredMethods)
        {
            System.out.println("方法:" + method.getName());
        }
        // 初始化对象
        User user = (User) classUser.newInstance();
        Field declaredField = classUser.getDeclaredField("id");
        // 标记为true 允许反射赋值
        declaredField.setAccessible(true);
        System.out.println("使用反射机制给id赋值为:" + user.getId());
        declaredField.set(user, "20");
        System.out.println("user:" + user.toString());

关于获取类的字段有两种方式：getFields()和getDeclaredFields()。我们先来看看这两者的区别吧：

getFields()：获得某个类的所有的公共（public）的字段，包括父类中的字段。 
getDeclaredFields()：获得某个类的所有声明的字段，即包括public、private和proteced，但是不包括父类的申明字段。

同样类似的还有getConstructors()和getDeclaredConstructors()、getMethods()和getDeclaredMethods()，这两者分别表示获取某个类的方法、构造函数。

JDBC反射加载驱动

maven的jar包依赖

        <!-- MySql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

表结构：

CREATE TABLE `users` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT ‘主键ID‘,
`name` varchar(255) DEFAULT NULL COMMENT ‘名字‘,
`age` int(11) DEFAULT NULL COMMENT ‘年龄‘,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;

演示代码：

package com.hongmoshui;

import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;

import com.mysql.jdbc.Connection;
import com.mysql.jdbc.PreparedStatement;

public class Text
{
    public static void main(String[] args) throws Exception
    {
        Connection connection =null;
        PreparedStatement statement = null;
        ResultSet resultSet  =null;
        try
        {
            // 加载驱动类
            Class.forName("com.mysql.jdbc.Driver");
            // 通过DriverManager获取数据库连接
            String url = "jdbc:mysql://localhost:3306/test";
            String user = "root";
            String password = "master";
            connection = (Connection) DriverManager.getConnection(url, user, password);
            // 获取预编译得SQL语句的对象
            statement = (PreparedStatement) connection.prepareStatement("insert into users (name, age) value (?, ?)");
            statement.setString(1, "hongmoshui");
            statement.setInt(2, 21);
            statement.executeUpdate();

            resultSet = statement.executeQuery("select * from users");
            // 操作ResultSet结果集
            while (resultSet.next())
            {
                // 第一种获取字段方式
                System.out.println(resultSet.getString(1) + " " + resultSet.getString(2) + " " + resultSet.getString(3));
            }
        }
        catch (ClassNotFoundException e)
        {
            e.printStackTrace();
            System.out.println("加载驱动失败");
        }
        catch (SQLException e)
        {
            e.printStackTrace();
        }
        finally
        {
            // 关闭数据库连接
            if (resultSet != null)
            {
                resultSet.close();
            }
            if (statement != null)
            {
                statement.close();
            }
            if (connection != null)
            {
                connection.close();
            }
        }
    }
}

禁止使用反射机制初始化

将构造函数为私有化

手写SpringIOC框架

什么是SpringIOC

什么是SpringIOC，就是把每一个bean(实体类)与bean(实体了)之间的关系交给第三方容器进行管理。

Xml配置:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
     http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
     http://www.springframework.org/schema/tx
     http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
     http://www.springframework.org/schema/aop
     http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
     http://www.springframework.org/schema/context
     http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <bean id="user1" class="com.hongmoshui.service.UserEntity">
        <property name="userId" value="0001"></property>
        <property name="userName" value="红墨水001"></property>
    </bean>
    <bean id="user2" class="com.hongmoshui.service.UserEntity">
        <property name="userId" value="0002"></property>
        <property name="userName" value="红墨水002"></property>
    </bean>
</beans>

Java代码:

UserEntity：

package com.hongmoshui.service;

public class UserEntity
{
    private String userId;

    private String userName;

    public UserEntity()
    {
        System.out.println("无参构造函数....");
    }

    public String getUserId()
    {

        return userId;
    }

    public void setUserId(String userId)
    {

        this.userId = userId;
    }

    public String getUserName()
    {

        return userName;
    }

    public void setUserName(String userName)
    {

        this.userName = userName;
    }

    @Override
    public String toString()
    {
        return "UserEntity [userId=" + userId + ", userName=" + userName + "]";
    }
}

main：

 　　　　//1.读取springxml配置
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext(
                "applicationContext.xml");
        //2.获取bean对象
        UserEntity userEntity = (UserEntity) classPathXmlApplicationContext.getBean("user2");
        System.out.println(userEntity);

什么是SpringIOC底层实现原理

1.读取bean的XML配置文件

2.使用beanId查找bean配置，并获取配置文件中class地址。

3.使用Java反射技术实例化对象

4.获取属性配置，使用反射技术进行赋值。

详细步骤：

1.利用传入的参数获取xml文件的流,并且利用dom4j解析成Document对象

2.对于Document对象获取根元素对象<beans>后对下面的<bean>标签进行遍历,判断是否有符合的id.

3.如果找到对应的id,相当于找到了一个Element元素,开始创建对象,先获取class属性,根据属性值利用反射建立对象.

4.遍历<bean>标签下的property标签,并对属性赋值.注意,需要单独处理int,float类型的属性.因为在xml配置中这些属性都是以字符串的形式来配置的,因此需要额外处理.

5.如果属性property标签有ref属性,说明某个属性的值是一个对象,那么根据id(ref属性的值)去获取ref对应的对象,再给属性赋值.

6.返回建立的对象,如果没有对应的id,或者<beans>下没有子标签都会返回null

Maven的jar包依赖：

　　<dependencies>
        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.4</version>
        </dependency>
        <dependency>
            <groupId>org.dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>2.0.0</version>
        </dependency>
    </dependencies>

建立实体类：

package com.hongmoshui.service;

public class User extends Object
{

    private String id;

    private String name;

    public User(String id)
    {
        System.out.println("有参构造函数, id:" + id);
        this.id = id;
    }

    public User()
    {
        System.out.println("无参构造函数...");
    }

    public String getId()
    {

        return id;
    }

    public void setId(String id)
    {

        this.id = id;
    }

    public String getName()
    {

        return name;
    }

    public void setName(String name)
    {

        this.name = name;
    }

    @Override
    public String toString()
    {
        return "User [id=" + id + ", name=" + name + "]";
    }

}

xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
     http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
     http://www.springframework.org/schema/tx
     http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
     http://www.springframework.org/schema/aop
     http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
     http://www.springframework.org/schema/context
     http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <bean id="user1" class="com.hongmoshui.service.User">
        <property name="id" value="0001"></property>
        <property name="name" value="红墨水001"></property>
    </bean>
    <bean id="user2" class="com.hongmoshui.service.User">
        <property name="id" value="0002"></property>
        <property name="name" value="红墨水002"></property>
    </bean>
</beans>

代码：

package com.hongmoshui.service;

import java.lang.reflect.Field;
import java.util.List;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.springframework.util.StringUtils;

public class Text
{

    private String pathXml = null;

    public Text(String pathXml)
    {
        this.pathXml = pathXml;
    }

    public Object getBean(String beanId) throws Exception
    {
        if (StringUtils.isEmpty(beanId))
        {
            throw new Exception("beanId is null");
        }
        SAXReader saxReader = new SAXReader();
        Document read = saxReader.read(this.getClass().getClassLoader().getResource(pathXml));
        // 获取到根节点
        Element rootElement = read.getRootElement();
        // 根节点下所有的子节点
        List<Element> elements = rootElement.elements();
        for (Element element : elements)
        {
            // 获取到节点上的属性
            String id = element.attributeValue("id");
            if (StringUtils.isEmpty(id))
            {
                continue;
            }
            if (!id.equals(beanId))
            {
                continue;
            }

            // 使用java反射机制初始化对象
            String beanClass = element.attributeValue("class");
            Class<?> forName = Class.forName(beanClass);
            Object newInstance = forName.newInstance();
            List<Element> propertyElementList = element.elements();
            for (Element el : propertyElementList)
            {
                String name = el.attributeValue("name");
                String value = el.attributeValue("value");
                Field declaredField = forName.getDeclaredField(name);
                declaredField.setAccessible(true);
                declaredField.set(newInstance, value);
            }
            return newInstance;

        }
        return null;
    }

    public static void main(String[] args) throws Exception
    {
        Text classPath = new Text("applicationContext.xml");
        User user = (User) classPath.getBean("user2");
        System.out.println(user.toString());

    }

}

原文地址：https://www.cnblogs.com/hongmoshui/p/10984024.html

时间： 2024-08-11 23:55:33

【学习】006数据交换格式与SpringIOC底层实现的相关文章

iOS 中 JSON 数据交换格式

     JSON (JavaScript Object Notation)是一种轻量级的数据交换格式.JSON 的具体教程,可以参见 JSON 中国:http://www.json.org.cn/index.htm ,当然还有 JSON 在线校验格式化工具:http://www.bejson.com/ ,希望深入学习 JSON 可以参考其他教程.JSON 的轻量级是相对于 XML 文档结构而言的,描述项目字符少,所以描述相同的数据所需的字符个数要少,当然传输的速度就会提高而流量也会减少.  

iOS 中 XML 数据交换格式

     XML 是一种自描述的数据交换格式,但是 XML 的数据交换格式并没有 JSON 来的轻便,但是无可否认的是,XML 的应用范围也是非常广泛的,比如在 ROS(一个开源机器人操作系统)中利用 XML 来描述包的依赖关系等,当然还有很多了.      对于 XML 文档操作包括了"读"与"写",读入 XML 文档并分析的过程称为"解析" XML 文档,"解析" XML 文档在实际开发中是占很大比重的.      读写

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式

JSON JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式. 它基于JavaScript(Standard ECMA-262 3rd Edition - December 1999)的一个子集. JSON采用完全独立于语言的文本格式,但是也使用了类似于C语言家族的习惯(包括C, C++, C#, Java, JavaScript, Perl, Python等). 这些特性使JSON成为理想的数据交换语言.易于人阅读和编写,同时也易于机器解析和生成. J

json 数据交换格式与java

http://wiki.mbalib.com/wiki/数据交换 数据交换是指为了满足不同信息系统之间数据资源的共享需要,依据一定的原则,采取相应的技术,实现不同信息系统之间数据资源共享的过程. 数据交换格式:需要交互的数据的封装格式: 主要考虑两点: 1)数据的组织: 2)数据类型的保真: http://baike.baidu.com/link?url=TPtlUBxpINIvU2Zc3NJDSlkDON133FUx3lp-IuNIzCHjfoRmZX8jgHUPrTbppDPffEXalnY

IOS开发之网络篇第一章：数据交换格式

网络通信最常用的数据通信格式是xml和Json,各有各的好处,不管怎样,这种的格式,我们在开发的过程中经常使用的,现在就这两种格式进行记录笔记,以下内容不做详细分析,只针对如何应用各种读写工具进行对xml和json内容的操作 xml 解析XML文件现在有两种主流的,SAX和DOM SAX-基于时间事件驱动,意思就是读取的过程中,是由上往下的读取xml文件,当遇到节点的时候,触发相应的事件,使用上比较快,缺点是不能修改文件内容 DOM-以树状形式加载,加载后存放在内存当中,所以如果文件大,读取的时

数据交换格式XML和JSON对比

1.简介: XML:extensible markup language,一种类似于HTML的语言,他没有预先定义的标签,使用DTD(document type definition)文档类型定义来组织数据:格式统一,跨平台和语言,早已成为业界公认的标准.具体的可以问Google或百度.相比之JSON这种轻量级的数据交换格式,XML可以称为重量级的了. JSON : JavaScript Object Notation 是一种轻量级的数据交换格式.易于人阅读和编写.同时也易于机器解析和生成.它基

在.NET使用JSON作为数据交换格式

我们知道在.NET中我们有多种对象序列化的方式,如XML方式序列化.Binary序列化,其中XML序列化是一种比较通用的在各语言之间传递数据的方式.除了这两种序列化方式之外,在.NET中还可以使用JSON序列化.JSON(JavaScript Object Notation)是一种轻量级轻量级的数据交换格式,并且它独立于编程语言,与XML序列化相比,JSON序列化后产生的数据一般要比XML序列化后数据体积小,所以在Facebook等知名网站中都采用了JSON作为数据交换方式.在.NET中有三种常

在.NET使用JSON作为数据交换格式【转】

http://www.cnblogs.com/zhoufoxcn/archive/2011/03/16/2515611.html 我们知道在.NET中我们有多种对象序列化的方式,如XML方式序列化.Binary序列化,其中XML序列化是一种比较通用的在各语言之间传递数据的方式.除了这两种序列化方式之外,在.NET中还可以使用JSON序列化.JSON(JavaScript Object Notation)是一种轻量级轻量级的数据交换格式,并且它独立于编程语言,与XML序列化相比,JSON序列化后产

在.NET使用JSON作为数据交换格式（转）

我们知道在.NET中我们有多种对象序列化的方式,如XML方式序列化.Binary序列化,其中XML序列化是一种比较通用的在各语言之间传递数据的方式.除了这两种序列化方式之外,在.NET中还可以使用JSON序列化.JSON(JavaScript Object Notation)是一种轻量级轻量级的数据交换格式,并且它独立于编程语言,与XML序列化相比,JSON序列化后产生的数据一般要比XML序列化后数据体积小,所以在Facebook等知名网站中都采用了JSON作为数据交换方式.在.NET中有三种常