Java中的XML读取

XML的作用

-不同软件间的数据传输

-不同系统间的数据传输

-不同平台间的数据共享

XML四种解析方式

-DOM解析

-SAX解析

-DOM4J解析

-JDOM解析

-DOM解析与SAX解析不需要额外的jar,是Java官方的解析方式。

-解析遇到乱码时可以修改xml中编码方式，或者对InputStream流进行InputStreamReader包装并指定编码方式。

常用XML节点类型

节点类型	NodeType	Named Constant	nodeName 的返回值	nodeValue的返回值
Element	1	ELEMENT_NODE	element name	null
Attr	2	ATTRIBUTE_NODE	属性名称	属性值
Text	3	TEXT_NODE	text	节点内容

DOM解析

-将整个xml加载到内存中再解析

-所解析的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:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:task="http://www.springframework.org/schema/task"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.0.xsd"> 
<!-- 引入外部属性文件 -->
<context:property-placeholder location="classpath:jdbc.properties"/>

<!-- 配置c3p0连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="${jdbc.driverClass}"/>
<property name="jdbcUrl" value="${jdbc.url}"/>
<property name="user" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>

<!-- 配置hibernate其他相关属性 -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
<!-- 注入连接池 -->
<property name="dataSource" ref="dataSource"/>
<!-- 配置hibernate属性 -->
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.format_sql">true</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
<!-- 加载hibernate配置文件 -->
<property name="mappingResources">
<list>
<value>entity/Employee.hbm.xml</value>
<value>entity/Department.hbm.xml</value>
</list>
</property>
</bean>

<!-- 配置Action -->
<bean id="employeeAction" class="action.EmployeeAciton" scope="prototype">
<property name="employeeService" ref="employeeService"/>
<property name="departmentService" ref="departmentService"/>
</bean>

<bean id="departmentAction" class="action.DepartmentAction" scope="prototype">
<property name="departmentService" ref="departmentService"/>
</bean>

<!-- 配置业务层 -->
<bean id="employeeService" class="service.EmployeeServiceImpl">
<property name="employeeDAO" ref="employeeDAO"/>
</bean>

<bean id="departmentService" class="service.DepartmentServiceImpl">
<property name="departmentDAO" ref="departmentDAO"/>
</bean>
<!-- 配置DAO -->
<bean id="employeeDAO" class="dao.EmployeeDAOImpl">
<property name="sessionFactory" ref="sessionFactory"/>
</bean>

<bean id="departmentDAO" class="dao.DepartmentDAOImpl">
<property name="sessionFactory" ref="sessionFactory"/>
</bean>

<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"/>
</bean>

<!-- 开启注解事务 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

</beans>

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.Element;

import org.w3c.dom.NamedNodeMap;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

import org.xml.sax.SAXException;

public class DOM {

public static void main(String[] args) {
// 创建一个DocumentBuilderFactory对象
DocumentBuilderFactory xDocumentBuilderFactory = DocumentBuilderFactory.newInstance();
try {
// 创建一个DocumentBuilder对象
DocumentBuilder xdocumentBuilder = xDocumentBuilderFactory.newDocumentBuilder();
// 传入要解析的XML文件
Document xDocument = xdocumentBuilder.parse("applicationContext.xml");
// 通过标签获得节点集合
NodeList beanList = xDocument.getElementsByTagName("bean");
System.out.println("共有" + beanList.getLength() + "个节点");
// 遍历每一个bean节点
for (int i = 0; i < beanList.getLength(); i++) {
// 获取其中一个节点
Node bean = beanList.item(i);
// 获取所有属性值
NamedNodeMap attrs = bean.getAttributes();
System.out.println("第" + (i + 1) + "个bean有" + attrs.getLength() + "个属性");
// 遍历节点属性
for (int j = 0; j < attrs.getLength(); j++) {
// 获取某一属性
Node attr = attrs.item(j);
// 获取属性名
System.out.println("属性名：" + attr.getNodeName());
// 获取属性值
System.out.println("属性值：" + attr.getNodeValue());
}
// 当不需要遍历所有属性时，采用以下方法可遍历个别已知属性
Element bean2 = (Element) beanList.item(i);
System.out.println("采用Element方式获得id：" + bean2.getAttribute("id"));
// 解析bean节点的子节点
NodeList childBean = bean.getChildNodes();
// 遍历 childBean每个节点的节点名和节点值，空白和换行符也会算作子节点
System.out.println("第" + (i + 1) + "bean" + "共有" + childBean.getLength() + "个子节点");
for (int j = 0; j < childBean.getLength(); j++) {
// 区分text类型的Node以及element类型的Node,过滤掉空白与换行符
if (childBean.item(j).getNodeType() == Node.ELEMENT_NODE) {
// 获取element类型节点的节点名
System.out.println("第" + (j + 1) + "个节点的节点名：" + childBean.item(j).getNodeName());
// element会把标签中的内容视为标签的子节点，所以要想获取内容需先访问子节点
if(childBean.item(j).getFirstChild() != null){
System.out.println("第" + (j + 1) + "个节点的节点值：" + childBean.item(j).getFirstChild().getNodeValue());
}
// 获取子节点的节点值以及标签之间的值
System.out.println("第" + (j + 1) + "个节点的节点值：" + childBean.item(j).getTextContent());
}
}
}
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

}

-Java代码

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.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class DOM {

public static void main(String[] args) {
// 创建一个DocumentBuilderFactory对象
DocumentBuilderFactory xDocumentBuilderFactory = DocumentBuilderFactory.newInstance();
try {
// 创建一个DocumentBuilder对象
DocumentBuilder xdocumentBuilder = xDocumentBuilderFactory.newDocumentBuilder();
// 传入要解析的XML文件
Document xDocument = xdocumentBuilder.parse("applicationContext.xml");
// 通过标签获得节点集合
NodeList beanList = xDocument.getElementsByTagName("bean");
System.out.println("共有" + beanList.getLength() + "个节点");
// 遍历每一个bean节点
for (int i = 0; i < beanList.getLength(); i++) {
// 获取其中一个节点
Node bean = beanList.item(i);
// 获取所有属性值
NamedNodeMap attrs = bean.getAttributes();
System.out.println("第" + (i + 1) + "个bean有" + attrs.getLength() + "个属性");
// 遍历节点属性
for (int j = 0; j < attrs.getLength(); j++) {
// 获取某一属性
Node attr = attrs.item(j);
// 获取属性名
System.out<
14764
span class="hljs-preprocessor">.println("属性名：" + attr.getNodeName());
// 获取属性值
System.out.println("属性值：" + attr.getNodeValue());
}
// 当不需要遍历所有属性时，采用以下方法可遍历个别已知属性
Element bean2 = (Element) beanList.item(i);
System.out.println("采用Element方式获得id：" + bean2.getAttribute("id"));
// 解析bean节点的子节点
NodeList childBean = bean.getChildNodes();
// 遍历 childBean每个节点的节点名和节点值，空白和换行符也会算作子节点
System.out.println("第" + (i + 1) + "bean" + "共有" + childBean.getLength() + "个子节点");
for (int j = 0; j < childBean.getLength(); j++) {
// 区分text类型的Node以及element类型的Node,过滤掉空白与换行符
if (childBean.item(j).getNodeType() == Node.ELEMENT_NODE) {
// 获取element类型节点的节点名
System.out.println("第" + (j + 1) + "个节点的节点名：" + childBean.item(j).getNodeName());
// element会把标签中的内容视为标签的子节点，所以要想获取内容需先访问子节点
if(childBean.item(j).getFirstChild() != null){
System.out.println("第" + (j + 1) + "个节点的节点值：" + childBean.item(j).getFirstChild().getNodeValue());
}
// 获取子节点的节点值以及标签之间的值
System.out.println("第" + (j + 1) + "个节点的节点值：" + childBean.item(j).getTextContent());
}
}
}
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}

共有9个节点

第1个bean有2个属性

属性名：class

属性值：com.mchange.v2.c3p0.ComboPooledDataSource

属性名：id

属性值：dataSource

采用Element方式获得id：dataSource

第1bean共有9个子节点

第2个节点的节点名：property

第2个节点的节点值：

第4个节点的节点名：property

第4个节点的节点值：

第6个节点的节点名：property

第6个节点的节点值：

第8个节点的节点名：property

第8个节点的节点值：

第2个bean有2个属性

属性名：class

属性值：org.springframework.orm.hibernate4.LocalSessionFactoryBean

属性名：id

属性值：sessionFactory

采用Element方式获得id：sessionFactory

第2bean共有13个子节点

第4个节点的节点名：property

第4个节点的节点值：

第8个节点的节点名：property

第8个节点的节点值：

第8个节点的节点值：

org.hibernate.dialect.MySQLDialect
true
true
update

第12个节点的节点名：property

第12个节点的节点值：

第12个节点的节点值：

entity/Employee.hbm.xml
entity/Department.hbm.xml

第3个bean有3个属性

属性名：class

属性值：action.EmployeeAciton

属性名：id

属性值：employeeAction

属性名：scope

属性值：prototype

采用Element方式获得id：employeeAction

第3bean共有5个子节点

第2个节点的节点名：property

第2个节点的节点值：

第4个节点的节点名：property

第4个节点的节点值：

第4个bean有3个属性

属性名：class

属性值：action.DepartmentAction

属性名：id

属性值：departmentAction

属性名：scope

属性值：prototype

采用Element方式获得id：departmentAction

第4bean共有3个子节点

第2个节点的节点名：property

第2个节点的节点值：

第5个bean有2个属性

属性名：class

属性值：service.EmployeeServiceImpl

属性名：id

属性值：employeeService

采用Element方式获得id：employeeService

第5bean共有3个子节点

第2个节点的节点名：property

第2个节点的节点值：

第6个bean有2个属性

属性名：class

属性值：service.DepartmentServiceImpl

属性名：id

属性值：departmentService

采用Element方式获得id：departmentService

第6bean共有3个子节点

第2个节点的节点名：property

第2个节点的节点值：

第7个bean有2个属性

属性名：class

属性值：dao.EmployeeDAOImpl

属性名：id

属性值：employeeDAO

采用Element方式获得id：employeeDAO

第7bean共有3个子节点

第2个节点的节点名：property

第2个节点的节点值：

第8个bean有2个属性

属性名：class

属性值：dao.DepartmentDAOImpl

属性名：id

属性值：departmentDAO

采用Element方式获得id：departmentDAO

第8bean共有3个子节点

第2个节点的节点名：property

第2个节点的节点值：

第9个bean有2个属性

属性名：class

属性值：org.springframework.orm.hibernate4.HibernateTransactionManager

属性名：id

属性值：transactionManager

采用Element方式获得id：transactionManager

第9bean共有3个子节点

第2个节点的节点名：property

第2个节点的节点值：

SAX解析

-通过自己创建的Handler处理类去逐个分析遇到的节点

-startElement解析开始节点

-endElement解析结束节点

主函数

import java.io.IOException;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.SAXException;

import entity.Bean;
import handler.SAXParserHandler;

public class SAX {

public static void main(String[] args) {
// 获取一个SAXParseFactory的实例
SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
try {
// 通过saxParserFactory获取SAXparse
SAXParser saxParser = saxParserFactory.newSAXParser();
// 创建handler对象
SAXParserHandler saxParserHandler = new SAXParserHandler();
saxParser.parse("applicationContext.xml", saxParserHandler);
System.out.println("bean个数："+saxParserHandler.getBeanList().size());
for (Bean bean : saxParserHandler.getBeanList()) {
System.out.println(bean.getId());
}
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}

处理类

import java.util.ArrayList;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

import entity.Bean;

public class SAXParserHandler extends DefaultHandler {
// 通过该全局变量确定已遍历的bean的数目
private int beanIndex = 0;
// 用于存放属性值
private String value = null;
// 创建一个bean对象
private Bean bean;
// 用于保存遍历过的bean
private ArrayList<Bean> beanList = new ArrayList<Bean>();

// 用来解析xml文件的开始标签
@Override
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
super.startElement(uri, localName, qName, attributes);
// 开始解析bean元素属性
if (qName.equals("bean")) {
// 创建一个bean对象
bean = new Bean();
// 遍历一个bean,则beanIndex+1;
beanIndex++;
// 获取属性的个数
int num = attributes.getLength();
for (int i = 0; i < num; i++) {
System.out.println("bean" + "第" + (i + 1) + "个属性名" + attributes.getQName(i));
System.out.println("属性值：" + attributes.getValue(i));
if (attributes.getQName(i).equals("id")) {
bean.setId(attributes.getValue(i));
}
}
} else {
System.out.println("节点名是：" + qName);
}
}

// 用来遍历xml的结束标签
@Override
public void endElement(String uri, String localName, String qName) throws SAXException {
super.endElement(uri, localName, qName);
if (qName.equals("bean")) {
beanList.add(bean);
bean = null;
System.out.println("第" + beanIndex + "个bean结束遍历");
} else if (qName.equals("class")) {
bean.setClazz(value);
} else if (qName.equals("scope")) {
bean.setScope(value);
}
}

// 标识解析开始
@Override
public void startDocument() throws SAXException {
super.startDocument();
System.out.println("SAX解析开始");
}

// 标识解析结束
@Override
public void endDocument() throws SAXException {
super.endDocument();
System.out.println("SAX解析结束");
}

// 获得节点值
@Override
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);
}
}

public ArrayList<Bean> getBeanList() {
return beanList;
}

}

实体类

public class Bean {
private String id;
private String clazz;
private String scope;

public String getId() {
return id;
}

public void setId(String id) {
this.id = id;
}

public String getClazz() {
return clazz;
}

public void setClazz(String clazz) {
this.clazz = clazz;
}

public String getScope() {
return scope;
}

public void setScope(String scope) {
this.scope = scope;
}

}

输出结果

SAX解析开始

节点名是：beans

节点名是：context:property-placeholder

bean第1个属性名id

属性值：dataSource

bean第2个属性名class

属性值：com.mchange.v2.c3p0.ComboPooledDataSource

节点名是：property

节点名是：property

节点名是：property

节点名是：property

第1个bean结束遍历

bean第1个属性名id

属性值：sessionFactory

bean第2个属性名class

属性值：org.springframework.orm.hibernate4.LocalSessionFactoryBean

节点名是：property

节点名是：property

节点名是：props

节点名是：prop

节点值：org.hibernate.dialect.MySQLDialect

节点名是：prop

节点值：true

节点名是：prop

节点值：true

节点名是：prop

节点值：update

节点名是：property

节点名是：list

节点名是：value

节点值：entity/Employee.hbm.xml

节点名是：value

节点值：entity/Department.hbm.xml

第2个bean结束遍历

bean第1个属性名id

属性值：employeeAction

bean第2个属性名class

属性值：action.EmployeeAciton

bean第3个属性名scope

属性值：prototype

节点名是：property

节点名是：property

第3个bean结束遍历

bean第1个属性名id

属性值：departmentAction

bean第2个属性名class

属性值：action.DepartmentAction

bean第3个属性名scope

属性值：prototype

节点名是：property

第4个bean结束遍历

bean第1个属性名id

属性值：employeeService

bean第2个属性名class

属性值：service.EmployeeServiceImpl

节点名是：property

第5个bean结束遍历

bean第1个属性名id

属性值：departmentService

bean第2个属性名class

属性值：service.DepartmentServiceImpl

节点名是：property

第6个bean结束遍历

bean第1个属性名id

属性值：employeeDAO

bean第2个属性名class

属性值：dao.EmployeeDAOImpl

节点名是：property

第7个bean结束遍历

bean第1个属性名id

属性值：departmentDAO

bean第2个属性名class

属性值：dao.DepartmentDAOImpl

节点名是：property

第8个bean结束遍历

bean第1个属性名id

属性值：transactionManager

bean第2个属性名class

属性值：org.springframework.orm.hibernate4.HibernateTransactionManager

节点名是：property

第9个bean结束遍历

节点名是：tx:annotation-driven

SAX解析结束

bean个数：9

dataSource

sessionFactory

employeeAction

departmentAction

employeeService

departmentService

employeeDAO

departmentDAO

transactionManager

JDOM解析

-需要jdom-2.0.6.jar

主类

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

import org.jdom2.Attribute;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;

import entity.Bean;

public class JDOM {
private static Bean beanEntity;
private static ArrayList<Bean> beanList = new ArrayList<Bean>();

public static void main(String[] args) {
// 创建SAXBuilder
SAXBuilder saxBuilder = new SAXBuilder();
try {
// 创建输入流，将xml加载到输入流中
InputStream inputStream = new FileInputStream("applicationContext.xml");
// 指定编码方式，防止中文乱码
InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
// 将输入流加载到saxBuilder中
Document document = saxBuilder.build(inputStreamReader);
// 获取根节点
Element rootElement = document.getRootElement();
// 获取子节点集合
List<Element> listElemrnt = rootElement.getChildren();
// 遍历子节点集合
for (Element bean : listElemrnt) {
// 创建bean对象
beanEntity = new Bean();
System.out.println("开始解析第" + (listElemrnt.indexOf(bean) + 1) + "bean");
// 解析bean属性
List<Attribute> attrlist = bean.getAttributes();
// 获取特定属性值
// System.out.println(bean.getAttributeValue("id"));
for (Attribute attribute : attrlist) {
// 获得节点名称
System.out.println("属性名：" + attribute.getName());
// 保存有意义的文本，自动过滤空格回车
System.out.println("属性值：" + attribute.getValue());
if (attribute.getName().equals("id")) {
beanEntity.setId(attribute.getValue());
}
}
// 对bean节点子孙节点及节点值进行遍历
List<Element> beanChildren = bean.getChildren();
for (Element child : beanChildren) {
// 获得节点名称
System.out.println("节点名：" + child.getName());
// 保存有意义的文本，自动过滤空格回车
System.out.println("节点值：" + child.getValue());
if (child.getName().equals("property")) {
beanEntity.setClazz(child.getValue());
}
}
beanList.add(beanEntity);
beanEntity = null;
System.out.println("集合长度："+beanList.size());
for (Bean beanElement : beanList) {
System.out.println(beanElement.getId());
}
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (JDOMException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}

}
}

输出结果

开始解析第1bean

属性名：location

属性值：classpath:jdbc.properties

集合长度：1

null

开始解析第2bean

属性名：id

属性值：dataSource

属性名：class

属性值：com.mchange.v2.c3p0.ComboPooledDataSource

节点名：property

节点值：

节点名：property

节点值：

节点名：property

节点值：

节点名：property

节点值：

集合长度：2

null

dataSource

开始解析第3bean

属性名：id

属性值：sessionFactory

属性名：class

属性值：org.springframework.orm.hibernate4.LocalSessionFactoryBean

节点名：property

节点值：

节点名：property

节点值：

org.hibernate.dialect.MySQLDialect
true
true
update

节点名：property

节点值：

entity/Employee.hbm.xml
entity/Department.hbm.xml

集合长度：3

null

dataSource

sessionFactory

开始解析第4bean

属性名：id

属性值：employeeAction

属性名：class

属性值：action.EmployeeAciton

属性名：scope

属性值：prototype

节点名：property

节点值：

节点名：property

节点值：

集合长度：4

null

dataSource

sessionFactory

employeeAction

开始解析第5bean

属性名：id

属性值：departmentAction

属性名：class

属性值：action.DepartmentAction

属性名：scope

属性值：prototype

节点名：property

节点值：

集合长度：5

null

dataSource

sessionFactory

employeeAction

departmentAction

开始解析第6bean

属性名：id

属性值：employeeService

属性名：class

属性值：service.EmployeeServiceImpl

节点名：property

节点值：

集合长度：6

null

dataSource

sessionFactory

employeeAction

departmentAction

employeeService

开始解析第7bean

属性名：id

属性值：departmentService

属性名：class

属性值：service.DepartmentServiceImpl

节点名：property

节点值：

集合长度：7

null

dataSource

sessionFactory

employeeAction

departmentAction

employeeService

departmentService

开始解析第8bean

属性名：id

属性值：employeeDAO

属性名：class

属性值：dao.EmployeeDAOImpl

节点名：property

节点值：

集合长度：8

null

dataSource

sessionFactory

employeeAction

departmentAction

employeeService

departmentService

employeeDAO

开始解析第9bean

属性名：id

属性值：departmentDAO

属性名：class

属性值：dao.DepartmentDAOImpl

节点名：property

节点值：

集合长度：9

null

dataSource

sessionFactory

employeeAction

departmentAction

employeeService

departmentService

employeeDAO

departmentDAO

开始解析第10bean

属性名：id

属性值：transactionManager

属性名：class

属性值：org.springframework.orm.hibernate4.HibernateTransactionManager

节点名：property

节点值：

集合长度：10

null

dataSource

sessionFactory

employeeAction

departmentAction

employeeService

departmentService

employeeDAO

departmentDAO

transactionManager

开始解析第11bean

属性名：transaction-manager

属性值：transactionManager

集合长度：11

null

dataSource

sessionFactory

employeeAction

departmentAction

employeeService

departmentService

employeeDAO

departmentDAO

transactionManager

null

DOM4J解析

主类

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 DOM4J {

public static void main(String[] args) {
SAXReader saxReader = new SAXReader();
try {
// 通过saxReader加载xml文件并获取document对象
Document document = saxReader.read(new File("applicationContext.xml"));
Element beans = document.getRootElement();
Iterator<Element> iterator = beans.elementIterator();
while (iterator.hasNext()) {
Element bean = iterator.next();
System.out.println("开始遍历："+bean.getName());
// 获取bean的属性名以及属性值
List<Attribute> beanList = bean.attributes();
for (Attribute attribute : beanList) {
System.out.println("节点名：" + attribute.getName());
System.out.println("节点值：" + attribute.getValue());
}
Iterator<Element> beanIt = bean.elementIterator();
while (beanIt.hasNext()) {
Element beanChild = beanIt.next();
System.out.println("子节点名：" + beanChild.getName());
System.out.println("子节点值：" + beanChild.getStringValue());
}
}
} catch (DocumentException e) {
e.printStackTrace();
}

}
}

输出结果

开始遍历：property-placeholder

节点名：location

节点值：classpath:jdbc.properties

开始遍历：bean

节点名：id

节点值：dataSource

节点名：class

节点值：com.mchange.v2.c3p0.ComboPooledDataSource

子节点名：property

子节点值：

子节点名：property

子节点值：

子节点名：property

子节点值：

子节点名：property

子节点值：

开始遍历：bean

节点名：id

节点值：sessionFactory

节点名：class

节点值：org.springframework.orm.hibernate4.LocalSessionFactoryBean

子节点名：property

子节点值：

子节点名：property

子节点值：

org.hibernate.dialect.MySQLDialect
true
true
update

子节点名：property

子节点值：

entity/Employee.hbm.xml
entity/Department.hbm.xml

开始遍历：bean

节点名：id

节点值：employeeAction

节点名：class

节点值：action.EmployeeAciton

节点名：scope

节点值：prototype

子节点名：property

子节点值：

子节点名：property

子节点值：

开始遍历：bean

节点名：id

节点值：departmentAction

节点名：class

节点值：action.DepartmentAction

节点名：scope

节点值：prototype

子节点名：property

子节点值：

开始遍历：bean

节点名：id

节点值：employeeService

节点名：class

节点值：service.EmployeeServiceImpl

子节点名：property

子节点值：

开始遍历：bean

节点名：id

节点值：departmentService

节点名：class

节点值：service.DepartmentServiceImpl

子节点名：property

子节点值：

开始遍历：bean

节点名：id

节点值：employeeDAO

节点名：class

节点值：dao.EmployeeDAOImpl

子节点名：property

子节点值：

开始遍历：bean

节点名：id

节点值：departmentDAO

节点名：class

节点值：dao.DepartmentDAOImpl

子节点名：property

子节点值：

开始遍历：bean

节点名：id

节点值：transactionManager

节点名：class

节点值：org.springframework.orm.hibernate4.HibernateTransactionManager

子节点名：property

子节点值：

开始遍历：annotation-driven

节点名：transaction-manager

节点值：transactionManager

四种解析方式进行对比

基础方法：DOM/SAX

-Java自带方法，具有平台无关性

-基于事件驱动

DOM解析过程

-将xml文件一次性加载入内存中，并形成DOM树

优点

-形成了树结构，直观并且易于理解，代码容易编写

-解析过程保留在内存中，方便修改

缺点

-当xml文件较大时，对内存耗费比较大，容易影响解析性能并造成内存溢出

SAX解析过程

-基于事件，一步一步解析

-每遇到一个标签则进行判断，采用handler中哪种方式进行处理

优点

-采用事件驱动模式，对内存耗费小

-适用于只需要处理xml中的数据时

缺点

-不易编码

-很难同时访问一个xml中的多处数据

JDOM与DOM/DOM4J

JDOM

-仅使用具体类而不使用接口

-API大量使用Collections类

DOM4J

-JDOM的智能分支，合并了许多超出基本xml文档表示的功能

-使用接口和抽象基本类的方法，是一个优秀的api

-性能优异，灵活性好，功能强大，易用

-源码开放

-建议使用

性能对比（速度由块到慢）

文件较小时

SAX>DOM>DOM4J>JDOM