优点
允许应用程序对数据和结构做出更改
访问是双向的,可以在任何时候在树中上、下导航获取、操作任意部分的数据
缺点
解析XML文档的需要加载整个文档来构造层次结构,消耗内存资源大。
应用范围
遍历能力强,常应用于XML文档需要频繁改变的服务中。
解析步骤
创建一个 DocumentBuilderFactory 对象
创建一个 DocumentBuilder 对象
通过 DocumentBuilder 的 parse() 方法加载 XML 到当前工程目录下
通过 getElementsByTagName() 方法获取所有 XML 所有节点的集合
遍历所有节点
通过 item() 方法获取某个节点的属性
通过 getNodeName() 和 getNodeValue() 方法获取属性名和属性值
通过 getChildNodes() 方法获取子节点,并遍历所有子节点
通过 getNodeName() 和 getTextContent() 方法获取子节点名称和子节点值
package Paint
import java.io.IOException
import javax.xml.parsers.DocumentBuilder
import javax.xml.parsers.DocumentBuilderFactory
import javax.xml.parsers.ParserConfigurationException
import org.w3c.dom.Document
import org.w3c.dom.NamedNodeMap
import org.w3c.dom.Node
import org.w3c.dom.NodeList
import org.xml.sax.SAXException
public class DOMTest {
public static void main(String[] args) {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance()
try {
DocumentBuilder db = dbf.newDocumentBuilder()
Document document = db.parse("./src/Paint/hello.xml")
NodeList bookList = document.getElementsByTagName("book")//节点集
int bookCnt = bookList.getLength()
System.err.println("一共获取到" + bookCnt +"本书")
for(int i=0iNode book = bookList.item(i)
NamedNodeMap attrs = book.getAttributes()
for(int j=0jNode attr = attrs.item(j)
System.err.println(attr.getNodeName()+"---"+attr.getNodeValue())//id
}
NodeList childNodes = book.getChildNodes()
for(int k=0kif(childNodes.item(k).getNodeType() == Node.ELEMENT_NODE){
System.out.println(childNodes.item(k).getNodeName()+"---" + childNodes.item(k).getTextContent())
}
}
}
} catch (ParserConfigurationException e) {
e.printStackTrace()
} catch (SAXException e) {
e.printStackTrace()
} catch (IOException e) {
e.printStackTrace()
}
}
}
SAX(Simple API for XML)解析
优点
不需要等待所有的数据被处理,解析就可以开始
只在读取数据时检查数据,不需要保存在内存中
可以在某一个条件满足时停止解析,不必要解析整个文档
效率和性能较高,能解析大于系统内存的文档
缺点
解析逻辑复杂,需要应用层自己负责逻辑处理,文档越复杂程序越复杂
单向导航,无法定位文档层次,很难同时同时访问同一文档的不同部分数据,不支持 XPath
解析步骤
获取一个 SAXParserFactory 的实例
通过 factory() 获取 SAXParser 实例
创建一个 handler() 对象
通过 parser 的 parse() 方法来解析 XML
SAXTest.java
package Paint
import java.io.IOException
import javax.xml.parsers.ParserConfigurationException
import javax.xml.parsers.SAXParser
import javax.xml.parsers.SAXParserFactory
import org.xml.sax.SAXException
public class SAXTest {
public static void main(String[] args) {
// 获取实例
SAXParserFactory factory = SAXParserFactory.newInstance()
try {
SAXParser parser = factory.newSAXParser()
SAXParserHandler handler = new SAXParserHandler()
parser.parse("./src/Paint/hello.xml", handler)
System.err.println("共有"+ handler.getBookList().size()+ "本书")
for(Book book : handler.getBookList()){
System.out.println(book.getName())
System.out.println("id=" + book.getId())
System.out.println(book.getAuthor())
System.out.println(book.getYear())
System.out.println(book.getPrice())
System.out.println(book.getLanguage())
}
} catch (ParserConfigurationException e) {
e.printStackTrace()
} catch (SAXException e) {
e.printStackTrace()
} catch (IOException e) {
e.printStackTrace()
}
}
}
SAXParserHandler.java
package Paint
import java.util.ArrayList
import org.xml.sax.Attributes
import org.xml.sax.SAXException
import org.xml.sax.helpers.DefaultHandler
public class SAXParserHandler extends DefaultHandler {
String value = null
Book book = null
private ArrayList bookList = new ArrayList()
public ArrayList getBookList() {
return bookList
}
/*
* XML 解析开始
*/
public void startDocument() throws SAXException {
super.startDocument()
System.out.println("xml 解析开始")
}
/*
* XML 解析结束
*/
public void endDocument() throws SAXException {
super.endDocument()
System.out.println("xml 解析结束")
}
/*
* 解析 XML 元素开始
*/
public void startElement(String uri, String localName, String qName,
Attributes attributes) throws SAXException {
super.startElement(uri, localName, qName, attributes)
if(qName.equals("book")){
book = new Book()
for(int i=0iSystem.out.println(attributes.getQName(i)+"---"+attributes.getValue(i))
if(attributes.getQName(i).equals("id")){
book.setId(attributes.getValue(i))
}
}
}else if(!qName.equals("bookstore")){
System.out.print("节点名:"+ qName + "---")
}
}
/*
*解析 XML 元素结束
*/
public void endElement(String uri, String localName, String qName)
throws SAXException {
super.endElement(uri, localName, qName)
if(qName.equals("book")){
bookList.add(book)
book = null
}
else if(qName.equals("name")){
book.setName(value)
}else if(qName.equals("year")){
book.setYear(value)
}else if(qName.equals("author")){
book.setAuthor(value)
}else if(qName.equals("price")){
book.setPrice(value)
}else if(qName.equals("language")){
book.setLanguage(value)
}
}
public void characters(char[] ch, int start, int length)
throws SAXException {
super.characters(ch, start, length)
// 获取节点值数组
value = new String(ch, start, length)
if(!value.trim().equals("")){
System.out.println("节点值:"+value)
}
}
}
一、 JSON (JavaScript Object Notation)一种简单的数据格式,比xml更轻巧。Json建构于两种结构:
1、“名称/值”对的集合(A collection of name/value pairs)。不同的语言中,它被理解为对象(object),纪录(record),结构(struct),字典(dictionary),哈希表(hash table),有键列表(keyed list),或者关联数组 (associative array)。 如:
{
“name”:”jackson”,
“age”:100
}
2、值的有序列表(An ordered list of values)。在大部分语言中,它被理解为数组(array)如:
{
“students”:
[
{“name”:”jackson”,“age”:100},
{“name”:”michael”,”age”:51}
]
}
二、java解析JSON步骤
A、服务器端将数据转换成json字符串
首先、服务器端项目要导入json的jar包和json所依赖的jar包至builtPath路径下(这些可以到JSON-lib官网下载:http://json-lib.sourceforge.net/)
然后将数据转为json字符串,核心函数是:
public static String createJsonString(String key, Object value)
{
JSONObject jsonObject = new JSONObject()
jsonObject.put(key, value)
return jsonObject.toString()
}
B、客户端将json字符串转换为相应的javaBean
1、客户端获取json字符串(因为android项目中已经集成了json的jar包所以这里无需导入)
public class HttpUtil
{
public static String getJsonContent(String urlStr)
{
try
{// 获取HttpURLConnection连接对象
URL url = new URL(urlStr)
HttpURLConnection httpConn = (HttpURLConnection) url
.openConnection()
// 设置连接属性
httpConn.setConnectTimeout(3000)
httpConn.setDoInput(true)
httpConn.setRequestMethod("GET")
// 获取相应码
int respCode = httpConn.getResponseCode()
if (respCode == 200)
{
return ConvertStream2Json(httpConn.getInputStream())
}
}
catch (MalformedURLException e)
{
// TODO Auto-generated catch block
e.printStackTrace()
}
catch (IOException e)
{
// TODO Auto-generated catch block
e.printStackTrace()
}
return ""
}
private static String ConvertStream2Json(InputStream inputStream)
{
String jsonStr = ""
// ByteArrayOutputStream相当于内存输出流
ByteArrayOutputStream out = new ByteArrayOutputStream()
byte[] buffer = new byte[1024]
int len = 0
// 将输入流转移到内存输出流中
try
{
while ((len = inputStream.read(buffer, 0, buffer.length)) != -1)
{
out.write(buffer, 0, len)
}
// 将内存流转换为字符串
jsonStr = new String(out.toByteArray())
}
catch (IOException e)
{
// TODO Auto-generated catch block
e.printStackTrace()
}
return jsonStr
}
}
2、获取javaBean
public static Person getPerson(String jsonStr)
{
Person person = new Person()
try
{// 将json字符串转换为json对象
JSONObject jsonObj = new JSONObject(jsonStr)
// 得到指定json key对象的value对象
JSONObject personObj = jsonObj.getJSONObject("person")
// 获取之对象的所有属性
person.setId(personObj.getInt("id"))
person.setName(personObj.getString("name"))
person.setAddress(personObj.getString("address"))
}
catch (JSONException e)
{
// TODO Auto-generated catch block
e.printStackTrace()
}
return person
}
public static List<Person>getPersons(String jsonStr)
{
List<Person>list = new ArrayList<Person>()
JSONObject jsonObj
try
{// 将json字符串转换为json对象
jsonObj = new JSONObject(jsonStr)
// 得到指定json key对象的value对象
JSONArray personList = jsonObj.getJSONArray("persons")
// 遍历jsonArray
for (int i = 0i <personList.length()i++)
{
// 获取每一个json对象
JSONObject jsonItem = personList.getJSONObject(i)
// 获取每一个json对象的值
Person person = new Person()
person.setId(jsonItem.getInt("id"))
person.setName(jsonItem.getString("name"))
person.setAddress(jsonItem.getString("address"))
list.add(person)
}
}
catch (JSONException e)
{
// TODO Auto-generated catch block
e.printStackTrace()
}
return list
}
答:4种。(或者说是两种,因为JDOM和DOM4J是DOM的两个特殊情况)1.SAX解析
解析方式是事件驱动机制!
SAX解析器,逐行读取XML文件解析,每当解析到一个标签的开始/结束/内容/属性时,触发事件。
可以在这些事件发生时,编写程序进行相应的处理。
优点:
分析能够立即开始,而不是等待所有的数据被处理。
逐行加载,节省内存,有助于解析大于系统内存的文档。
有时不必解析整个文档,它可以在某个条件得到满足时停止解析。
缺点:
1.单向解析,无法定位文档层次,无法同时访问同一个文档的不同部分数据(因为逐行解析,当解析第n行时,第n-1行)已经被释放了,无法再对其进行操作)。
2. 无法得知事件发生时元素的层次, 只能自己维护节点的父/子关系。
3. 只读解析方式, 无法修改XML文档的内容。
2. DOM解析
是用与平台和语言无关的方式表示XML文档的官方W3C标准,分析该结构通常需要加载整个 文档和内存中建立文档树模型。程序员可以通过操作文档树, 来完成数据的获取 修改 删除等。
优点:
文档在内存中加载, 允许对数据和结构做出更改。访问是双向的,可以在任何时候在树中双向解析数据。
缺点:
文档全部加载在内存中 , 消耗资源大。
3. JDOM解析
目的是成为Java特定文档模型,它简化与XML的交互并且比使用DOM实现更快。由于是第一 个Java特定模型,JDOM一直得到大力推广和促进。
JDOM文档声明其目的是“使用20%(或更少)的精力解决80%(或更多)Java/XML问题” (根据学习曲线假定为20%)
优点:
使用具体类而不是接口,简化了DOM的API。
大量使用了Java集合类,方便了Java开发人员。
缺点:
没有较好的灵活性。
性能不是那么优异。
4. DOM4J解析
它是JDOM的一种智能分支。它合并了许多超出基本XML文档表示的功能,包括集成的XPath 支持、XML Schema支持以及用于大文档或流化文档的基于事件的处理。它还提供了构建文档表示的选项, DOM4J是一个非常优秀的Java XML API,具有性能优异、功能强大和极端易用使用的特点,同时它也是一 个开放源代码的软件。如今你可以看到越来越多的Java软件都在使用DOM4J来读写XML。
目前许多开源项目中大量采用DOM4J , 例如:Hibernate。