DOM4J 解析 xml 文件步骤
1、创建一个 SAXReader 对象
    SAXReader saxReader = new SAXReader();
2、将 xml 文件加载到 SAXReader 中，并获取 document 对象
    Document document = saxReader.read(fileName);
3、通过 getRootElement() 获取根节点元素
    Element employeeRoot = document.getRootElement();
4、通过 elementIterator() 获取子节点元素，返回 Iterator 返回迭代器
    Iterator eles = eleRoot.elementIterator();
5、通过 while 遍历迭代器
    while(eles.hasNest()){
    Element ele = (Element)eles.next();}
6、获取属性节点类似 JDOM 解析
    List<Attribute> attrs = ele.attributes();
7、获取元素节点名、值
    ele.getName() ele.getStringValue()/ele.getText()
8、获取属性节点名、值
    ele.getName() ele.geValue()

导入jar包的两种方式：
1.通过右键项目，选择build Path下的Add External Archives导入系统任意路径下的jar包。但是这种方式并没有将jar包真正导入项目中，一旦迁移，则会丢失
2.通过右键项目，新建lib文件夹，直接将jar包拷贝到lib文件夹下，然后再通过build Path将jar包导入进来

在JDOM中存储对象
1.创建一个新的book类并将其实例化
Book bookEntity = new Book();
2.添加节点属性值到book
if(attrName.equals("id")){
personEntity.setId(attrValue);
}
3.添加子节点属性值到book
if (child.getName().equals("name")) {
bookEntity.setName(child.getValue());
}
else if (child.getName().equals("author")) {
bookEntity.setAuthor(child.getValue());
}
else if (child.getName().equals("year")) {
bookEntity.setYear(child.getValue());
}
else if (child.getName().equals("price")) {
bookEntity.setPrice(child.getValue());
}
else if (child.getName().equals("language")) {
bookEntity.setLanguage(child.getValue());
}

JDOM 解析时乱码的处理步骤：
1)修改xml文件的编码
2)将InputStream封装为一个InputStreamReader，并在InputStreamReader的构造函数中指定正确的编码，然后将InputStreamReader传入到SAXBuilder中就可以处理中文乱码了
利用代码问题解决局部乱码问题（需要利用InputStreamReader来解决）
（1）InputStream in=new FIleStream("book.xml");
（2）InputStreamReader isr = new InputStreamReader(in, "utf-8");
（3）Document document = saxBuilder.build(isr);

DOM 解析
获取节点名、值：getNodeName() getNodeValue() getTextContent()
获取子节点：getChildNodes() 返回 NodeList
获取属性节点：getAttributes() 返回 NamedNodeMap
JDOM 解析
获取节点名、值：getName() getValue()
获取子节点：getChildren() 返回 List<Element>
获取属性节点：getAttributes() 返回 List<Attribute>

//继续进行解析
for (Element book : bookList) {
 System.out.println("===开始解析第"+(bookList.indexOf(book)+1)+"本书===");
 //解析book的属性
 List<Attribute> attrList = book.getAttributes();
//    //知道节点下属性名称时，获取节点值
//    book.getAttributeValue("id");
 //遍历attrList(针对不清楚book节点下属性的名字和数量)
 for (Attribute attr : attrList) {
  //遍历属性名
  String attrName = attr.getName();
  //遍历属性值
  String attrValue = attr.getValue();
  System.out.println("属性名："+attrName+"---属性值："+attrValue);
 }
 System.out.println("===结束解析第"+(bookList.indexOf(book)+1)+"本书===");
}

JDOM的解析步骤
1.获取SAXBuilder对象
2.将文件加载到SAXBuilder中，并获取Document对象
3.通过Document对象获取文件的根节点
4.有了根节点，通过根节点获取它的孩子节点书的集合
5.循环遍历孩子节点集合，通过getAttributes方法获取节点的属性Attribute集合
6.通过attribute的getName和getValue方法分别获取属性的名称和值
7.获得book下的节点，通过book节点对象的getChildren（）方法获取子节点的集合
8.再通过子节点的getName和getValue方法获取节点名和节点的值

JDOM解析文件步骤
准备：导入jar包
1.创建一个SAXBuilder对象
    SAXBuilder saxbuilder=newSAXBuilder();
2.创建输入流，将xml文件加载到输入流中
    Inputstream in=new FileInputstream("xxx.xml");
3.通过SAXBuilder的Build方法将输入流加载到saxb中获取dom对象
    Document doc = saxbuilder.build(in);
4.通过document对象获取xml文件的根结点
    Element rootElement =doc.getRootElement();
5.获取根结点下的子节点的List集合


JDOM 开始解析前的准备工作

//进行对books.xml文件的JDOM解析
//准备工作
//1.创建一个SAXBuilder的对象
SAXBuilder saxBuilder = new SAXBuilder();
InputStream in;
try {
 //2.创建一个输入流，将xml文件加载到输入流中来
 in = new FileInputStream("books.xml");
 //3.通过saxBuilder的build方法，将输入流加载到saxBuilder中
 Document document = saxBuilder.build(in);
 //4.通过document对象获取xml文件的根节点
 Element rootElement = document.getRootElement();
 //5.获取根节点下的子节点的List集合
 List<Element> bookList = rootElement.getChildren();
} catch (FileNotFoundException e) {
 e.printStackTrace();
} catch (JDOMException e) {
 e.printStackTrace();
} catch (IOException e) {
 e.printStackTrace();
}

xml的SAX解析并将解析的内容及xml结构形式保存至Java对象中。
SAX解析：
1、获取一个SAXParserFactory的实例:SAXParserFactory factory = SAXParserFactory.newInstance();
2、通过factory获取SAXParser实例：SAXParser parser = factory.newSAXParser();
3、创建SAXParserHandler对象：SAXParserHandler handler = new SAXParserHandler();
4、将xml文件和解析方式handler加载到SAXParser实例：parser.parse("books.xml",handler);
解析的时候，是startElement-characters-endElement ， characters解析完一个属性，就到endElement，然后又解析一个属性又到endElement,最后解析完全部属性，到endElement又到startElement开始下一个节点。
ArrayList保存对象 ArrayList<Book> BookList=new ArrayList<Book>();
BookList.add（book）;book=null;后继续遍历
public void startElement(String uri, String localName, String qName,Attributes attributes) throws SAXException// qName是String类型节点名称；attributes是Attributes类型的实例，属性的意思；

/**
  * 获取节点值
  */
 @Override
 public void characters(char[] ch, int start, int length) throws SAXException {
  super.characters(ch, start, length);
  String value = new String(ch, start, length);
  if(!value.trim().equals("")){
   System.out.println("节点值："+value);
  }
 }

 /**
  * 用来遍历xml文件的开始标签
  */
 @Override
 public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
  //调用DefaultHandler类的startElement()方法
  super.startElement(uri, localName, qName, attributes);
  //开始解析book元素的属性
  if(qName.equals("book")){
//   //已知book元素下属性的名称，根据属性名称获取属性值
//   String value = attributes.getValue("id");
//   System.out.println("book的属性值是："+value);
   //不知道book元素下属性的名称以及个数，如何获取属性名以及属性值
   int num = attributes.getLength();
   for(int i=0;i<num;i++){
    System.out.print("book元素的第"+(i+1)+"个属性名："+attributes.getQName(i));
    System.out.println("--属性值："+attributes.getValue(i));
   }
  }
 }

DOM：全部读取先
SAX解析：通过handler处理类逐个分析每个节点，从外到内逐个解析。。一个一个来
startElement, endElement(开始标签解析，结束标签解析）

步骤：
1.通过SAXParserFactory的静态newInstance()方法获取SAXParserFactory实例factory
SAXParserFactory factory = SAXParserFactory.newInstance();

2.通过SAXParserFactory实例的newSAXParser()方法返回SAXParser实例parser
SAXParser parser = factory.newSAXParser();
parser.parse("路径",handler类型对象)；（需创建见3）

3.创建一个类继承DefaultHandler,重写其中一些方法进行业务处理并创建这个类的实例handler
创建一个package继承DefaultHandler（。com那个）
startElement()
用于遍历xml的开始标签
endElement()
遍历xml结束标签
startElement
解析开始
endElement
解析结束

SAX解析xml步骤
1.通过SAXParseFactory的静态newInstance（）方法获取SAXParserFactory实例factory
2.通过SAXParserFactory实例的newSAXParser（）方法返回SAXParser实例parser
3.创建一个类继承DefaultHandle，重写方发进行业务已处理创建这个类的实例handle

SAX解析原理

DOM解析XML文件的节点名与节点值

//解析book节点的子节点
NodeList childNodes = book.getChildNodes();
//遍历childNodes获取每个节点的节点名和节点值
System.out.println("第"+(i+1)+"本书共有"+childNodes.getLength()+"个子节点");
for(int k=0;k<childNodes.getLength();k++){
 //区分出text类型的node以及element类型的node
 if(childNodes.item(k).getNodeType()==Node.ELEMENT_NODE){
  //获取element类型节点的节点名
  System.out.print("第"+(k+1)+"个节点的节点名："+childNodes.item(k).getNodeName());
  //获取element类型节点的节点值
  //getFirstChild().getNodeValue()方法把第一个子节点的节点值输出
  //System.out.println("--节点值是"+childNodes.item(k).getFirstChild().getNodeValue());
  //getTextContent()方法把element类型的node中的文本全部输出
  System.out.println("--节点值："+childNodes.item(k).getTextContent());
 }
}

DOM解析XML文件的属性名和属性值

  //创建一个DocumentBuilderFactory的对象
  DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
  
  //创建一个DocumentBuilder的对象
  try {
   //创建DocumentBuilder对象
   DocumentBuilder db = dbf.newDocumentBuilder();
   //通过DocumentBuilder对象的parser方法加载books.xml文件到当前项目下
   Document document = db.parse("books.xml");
   //获取所有book节点的集合
   NodeList bookList = document.getElementsByTagName("book");
   //通过NodeList的getLength()方法获取bookList的长度
   System.out.println("一共有"+bookList.getLength()+"本书");
   //遍历每一个book节点
   for(int i=0;i<bookList.getLength();i++){
    //前提：不知道属性名和属性个数
//    //通过item(i)方法获取一个book节点,NodeList的索引值从0开始
//    Node book = bookList.item(i);
//    //获取book节点的所有属性集合
//    NamedNodeMap attrs = book.getAttributes();
//    System.out.println("第"+(i+1)+"本书共有"+attrs.getLength()+"个属性");
//    //遍历book的属性
//    for(int j=0;j<attrs.getLength();j++){
//     //通过item(index)方法获取book节点的某一个属性
//     Node attr = attrs.item(j);
//     //获取属性名
//     System.out.print("属性名："+attr.getNodeName());
//     //获取属性值
//     System.out.println("--属性值："+attr.getNodeValue());
//    }
    
    //前提：已经知道book节点有且只能有1个id属性
    //将book节点进行强制类型转换，转换成Element类型
    Element book = (Element)bookList.item(i);
    //通过getAttribute("id")方法获取属性值
    String attrValue = book.getAttribute("id");
    System.out.println("id属性的属性值为"+attrValue);
    
   }
  } catch (ParserConfigurationException e) {
   e.printStackTrace();
  } catch (SAXException e) {
   e.printStackTrace();
  } catch (IOException e) {
   e.printStackTrace();
  }