【Java 强化】单元测试（JUnit3、JUnit4）、XML（语法、约束、文档结构）、DOM、DOM4J

Java笔记目录可以点这里： Java强化笔记

软件测试

有一句话这么说：优秀的软件不是开发出来的，而是测试出来的。

软件测试可分为：黑盒测试、白盒测试。

黑盒测试：软件测试工程师

黑盒测试也称功能测试，它是通过测试来检测每个功能是否都能正常使用。

在测试中，把程序看作一个不能打开的黑盒子，在完全不考虑程序内部结构和内部特性的情况下，在程序接口进行测试，它只检查程序功能是否按照需求规格说明书的规定正常使用，程序是否能适当地接收输入数据而产生正确的输出信息。

黑盒测试着眼于程序外部结构，不考虑内部逻辑结构，主要针对软件界面和软件功能进行测试。

黑盒测试是以用户的角度，从输入数据与输出数据的对应关系出发进行测试的。
很明显，如果外部特性本身设计有问题或规格说明的规定有误，用黑盒测试方法是发现不了的。

作用：黑盒测试法注重于测试软件的功能需求，主要试图发现下列几类错误。

• 功能不正确或遗漏；
• 界面错误；
• 输入和输出错误；
• 数据库访问错误；
• 性能错误；
• 初始化和终止错误等。

白盒测试：软件开发工程师

白盒测试又称结构测试、透明盒测试、逻辑驱动测试或基于代码的测试。

它是按照程序内部的结构测试程序，通过测试来检测产品内部动作是否按照设计规格说明书的规定正常进行，检验程序中的每条通路是否都能按预定要求正确工作。 这一方法是把测试对象看作一个打开的盒子，测试人员依据程序内部逻辑结构相关信息，设计或选择测试用例，对程序所有逻辑路径进行测试，通过在不同点检查程序的状态，确定实际的状态是否与预期的状态一致。

白盒测试是一种测试用例设计方法，盒子指的是被测试的软件，白盒指的是盒子是可视的，你清楚盒子内部的东西以及里面是如何运作的。

"白盒"法全面了解程序内部逻辑结构、对所有逻辑路径进行测试。测试者必须检查程序的内部结构，从检查程序的逻辑着手，得出测试数据。

单元测试（JUnit3、JUnit4）

单元测试属于白盒测试。

在你不知道如何测试代码前,就不要写代码去完成功能 —> 测试先行

Java的单元测试：Junit 目前存在三个版本

1. junit3.x：针对于Java5 之前的版本，没有注解，得按照规范来写测试。
2. junit4.x：针对于Java5 以后的版本，使用注解。
3. junit5.x：针对于 Java8 以后的版本。

我们这里就是对单元测试有个简单认识，会简单利用 3 和 4 编写一些测试代码。

测试环境搭建：将 junit 的测试 jar，添加到该项目中。

使用 junit3.x（了解）

junit3.x 是 Java5 以前的测试方式。

测试步骤:

1. 把 junit3.x 的测试 jar，添加到项目中；
2. 定义一个测试类，并让该测试类继承 TestCase；
   测试类的名字：XxxTest，Xxx 表示一个对象或者一个模块、组件。
3. 在 EmployeeDAOTest 中编写测试方法；
   方法是 public 修饰，无返回值、无参数的。
   必须以 test 作为方法的前缀，Xxx 表示测试的功能名字。

public void testXxx() throws Exception {}

4. 选择某一个测试方法，鼠标右键选择 [run as junit]；
   或者选中测试类，表示测试该类中所有的测试方法。

• 若要在测试方法之前做准备操作：
  EmployeeDAOTest 覆写 TestCase 中 protected void setUp() throws Exception 方法；
• 若要在测试方法之后做回收操作：
  EmployeeDAOTest 覆写 TestCase 中 protected void tearDown() throws Exception 方法；
• 测试执行顺序： setUp -> 测试方法 -> tearDown -> setUp -> 测试方法2 -> tearDown …

示例：利用 JUnit3 编写 EmployeeDAOTest 的测试类。

package com.yusael._01_junit.junit3;

import junit.framework.TestCase;

// EmployeeDAO组件的测试类
public class EmployeeDAOTest extends TestCase {
	@Override // 初始化操作
	protected void setUp() throws Exception {
		System.out.println("初始化操作");
	}
	@Override // 销毁操作
	protected void tearDown() throws Exception {
		System.out.println("销毁操作");
	}
	// 测试员工的保存操作
	public void testSave() throws Exception {
		System.out.println("保存测试");
	}
	// 测试员工的删除操作
	public void testDelete() throws Exception {
		System.out.println("删除测试");
	}
}

使用 junit4.x（掌握）

junit4.x 基于 Java5 开始的版本，支持注解。

步骤:

1. 把 junit4.x 的测试 jar，添加到项目中;；
2. 定义一个测试类。（不再继承 TestCase 类）
   测试类的名字: XxxTest
3. 在 EmployeeDAOTest 中编写测试方法；
   方法是 public 修饰的，无返回的；
   该方法上必须贴有 @Test 标签，Xxx 表示测试的功能名字。

@Test
public void testXxx() throws Exception {}

4. 选择某一个测试方法，鼠标右键选择 [run as junit]；
   或者选中测试类，表示测试该类中所有的测试方法。

以后单元测试使用最多的方式：

• 若要在测试方法之前做准备操作：
  EmployeeDAOTest 随意定义一个方法并使用 @Before 标注；
  每次执行测试方法之前都会执行 @Before 标注的方法

@Before
public void xx() throws Exception {}

• 若要在测试方法之后做回收操作：
  EmployeeDAOTest 随意定义一个方法并使用 @After 标注；
  每次执行测试方法之后都会执行 @After 标注的方法；

@After
public void xx() throws Exception {}

• 有没有方式只初始化一次，和最终只销毁一次呢？
  @BeforeClass 标签：在所有的 Before 方法之前执行，只在最初执行一次， 只能修饰静态方法。
  @AfterClass 标签：在所有的 After 方法之后执行，只在最后执行一次，只能修饰静态方法。

• 测试执行顺序：BeforeClass -> (Before -> Test -> After -> … ) -> AfterClass

示例：利用 JUnit4 编写 EmployeeDAOTest 的测试类。

package com.yusael._01_junit.junit4;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

// EmployeeDAO组件的测试类
public class EmployeeDAOTest {
	@BeforeClass
	public static void staticInit() throws Exception {
		System.out.println("static - Init");
	}
	@AfterClass
	public static void staticDestroy() throws Exception {
		System.out.println("static - Destroy");
	}
	@Before
	public void Init() throws Exception {
		System.out.println("初始化操作");
	}
	@After
	public void Destory() throws Exception {
		System.out.println("销毁操作");
	}
	@Test
	public void testSave() throws Exception {
		System.out.println("保存测试");
	}
	@Test
	public void testDelete() throws Exception {
		System.out.println("删除测试");
	}
}

使用断言方式（了解）

这个不是很常用，只需要了解即可。

期望值: 断言时希望是多少。
真实值: 程序内部运算之后实际是多少。

断言成功: 期望值和真实值相同，此时显示绿条。
断言失败: 期望值和真实值不同，此时显示红条。

断言：

• Assert.assertEquals(message, expected, actual)：比较的值
  message：断言失败的提示信息，断言成功不会显示
  expected：期望值
  actual：真实值
  若真实值和期望值想等，则断言成功 —> 绿条
• Assert.assertSame(message, expected, actual)：比较地址，断言是同一个对象
  Assert.assertNotSame(message, expected, actual)：断言不是同一个对象
• Assert.assertTrue(message, condition)：断言 condition 应该为 TRUE
  Assert.assertFalse(message, condition)：断言 condition 应该为 FALSE
• Assert.assertNull(message, object)：断言对象 object 为 null
  Assert.assertNotNull(message, object)：断言对象 object 不为 null
• @Test(expected=ArithmeticException.class)：期望该方法抛出 ArithmeticException 异常
• @Test(timeout=400)：期望该方法在400毫秒之内执行完成

示例：利用断言进行对数学方法类进行测试。

package com.yusael._01_junit.asserted;

/**
 * 数学运算功能
 * @author yusael
 */
public interface IMath {
	/**
	 * 两个数相加
	 * @param a 加数
	 * @param b 加数
	 * @return 两个数之和
	 */
	int add(int a, int b);
	
	/**
	 * 两个数之商（考虑整除）
	 * @param a 被除数
	 * @param b 除数
	 * @return 商
	 */
	int divide(int a, int b);
}

package com.yusael._01_junit.asserted.impl;

import com.yusael._01_junit.asserted.IMath;

public class MathImpl implements IMath {
	@Override
	public int add(int a, int b) {
		return a + b;
	}

	@Override
	public int divide(int a, int b) {
		return a / b;
	}

}

package com.yusael._01_junit.asserted;

import org.junit.Test;
import com.yusael._01_junit.asserted.impl.MathImpl;
import junit.framework.Assert;

// Math测试类
public class MathTest {
	// 依赖关系
	private IMath math = new MathImpl();
	@Test
	public void testAdd() {
		int ret = math.add(1, 2);
		Assert.assertEquals(3, ret);
	}
	@Test
	public void testDivide() {
		int ret = math.divide(6, 2);
		Assert.assertEquals(3, ret);
	}
	// 期望抛出ArithmeticException异常, 不抛则测试不通过
	@Test(expected=ArithmeticException.class) 
	public void testException() {
		math.divide(2, 0); // 抛出ArithmeticException异常, 测试通过
	}
}

XML 以及约束

XML(eXtensible Markup Language)，是一种可扩展的标记语言，类似 HTML。

XML技术是W3C组织(World Wide Web Consortium万维网联盟)发布的，目前遵循的是W3C组织于2000年发布的XML1.0规范。
XML被广泛认为是继Java之后在Internet上最激动人心的新技术。
XML的树状结构简单,清晰，无论是人还是计算机都能轻松解析。
XML作为一种公订的、开放的标准，不受知识产权的限制。

HTML: 显示页面,网页. 学习里面自带的标签
XML: 传输数据，而非显示数据。
XML标签没有被预定义，需要用户自行定义标签。

为什么要学XML：

• XML是一种通用的数据交换格式；
• 许多项目都采用XML作为数据交换格式；
• 掌握XML是软件开发人员的一项基本技能；
  Struts、Spring、Hibernate、Mybatis 等任意一个 Java EE 框架中都可用XML做配置文件。

XML语法

XML有两个编码: 内容编码、文件本身的编码；要保证两个编码相同，都为 UTF-8。

一个XML文档必须有且仅有一个根标签，不允许标签嵌套，区分大小写。

在编写XML文档时，

• 需要先使用文档声明来声明XML文档，且必须出现在文档的第一行。
  最简单的语法，如：<?xml version="1.0"?>
• 用 encoding 属性说明文档所使用的字符编码，默认为 UTF-8。
  保存在磁盘上的文件编码要与声明的编码一致。
  如：<?xml version="1.0" encoding="UTF-8"?>
• 用 standalone 属性说明文档是否独立，即是否依赖其他文档。
  如：<?xml version=”1.0” standalone=”yes”?>

CDATA 是 Character Data 的缩写：

• 作用：把标签当做普通文本内容；
  解析器不对 CDATA 区中的内容进行解析，而是将这些数据原封不动地交给程序去处理。
• 语法：<![CDATA[数据内容]]>

xml 一般情况下不会要求去写，大致看得懂即可。

<?xml version="1.0" encoding="UTF-8"?>
<contacts>
	<linkman id="1">
		<name>Will</name>
		<email>[email protected]</email>
		<address>成都</address>
		<group>叩丁狼教育</group>
	</linkman>
	<linkman id="2">
		<name>Stef</name>
		<email>[email protected]</email>
		<address>成都</address>
		<group>叩丁狼教育</group>
	</linkman>
</contacts>

DTD 约束（了解）

Scheme 约束（了解）

DOM

DOM（Document Object Model）：文档对象模型

• 使用面问对象的方式，把 XML 文件中的结构使用对象来表示。

在 XML 中，一切皆节点（Wode）。

• Node：节点
  • Document：文档节点（XML 文件）
  • Element：元素节点（使用 <> 表示标签）
  • Attribute：属性节点（元素上属性名 = “属性值”）
  • Text：文本节点（元素之间的内容）

获取Document文档对象

DOM（Document Object Model）：文档对象模型

• 使用面问对象的方式，把 XML 文件中的结构使用对象来表示。
  使用 Java 代码操作 XML
  使用 JavaScript 操作 HTML

特点：

• 在加载的时候，一次性把整个XML文档加载进内存，在内存中形成一颗树对象（Document ）。
• 我们以后使用代码操作 Document，其实操作的是内存中的 DOM 树；和本地磁盘中的XML文件没有直接关系。
• 比如：我保存了一个联系人，仅仅是内存中多了一个联系人，但是在XML文件中没有新增的痕迹。除非做 同步操作：把内存中的数据更新到XML文件。（ 增删改操作完之后，都需要做同步操作。）
• 缺点：若XML文件过大，可能造成内存溢出。

获取 Document 文档对象：

package com.yusael._03_dom;

import java.io.File;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.junit.Test;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

// DOM操作测试类
public class DOMTest {
	private File f = new File("F:/java/JavasePro/JUnit-XML-DOM-DOM4J/contacts.xml");
	// 如何获取Document文档对象
	@Test
	public void testGetDocument() throws Exception {
		// 1):创建DocumentBuilderFactory对象(意识:工厂类中一般都有一个静态方法用于返回当前工厂类对象)
		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
		// 2):根据工厂对象, 创建DocumentBuilder对象
		DocumentBuilder builder = factory.newDocumentBuilder();
		// 3):根据builder对象去解析一个已经存在的XML文件, 从而得到Document对象.
		Document doc = builder.parse(f); // [#document: null]
	}
}

根据 DocumentBuilder 创建 Document 对象，有两种方式：

• 当XML文档不存在时，使用 newDocument()，在内存中先创建出一颗 树对象（Document）。

Document doc=builder.newDocument();

• 当XML文档存在时，我们只需要直接解析即可。

Document doc = builder.parse(File对象);

什么是解析（parse）：一般而言，把使用 String 描述的事物，转换为描述该事物的类型。

// 解析时间
Date d = DateFormat对象.parse("2018-10-10");

得到某个具体的文本节点的内容：取出第二个联系人的名字

操作步骤：

1. 获取 Document 文档对象
2. 获取 XML 中的根元素 contacts
3. 获取第二个联系人元素 linkman
4. 获取 linkman 元素下的 name 子元素
5. 获取 name 元素的文本内容

// 需求1、得到某个具体的文本节点的内容:取出第二个联系人的名字.
@Test
public void test1() throws Exception {
	// 1):获取Document文档对象.
	Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(f);
	// 2):获取XML中的根元素(contacts).
	Element root = doc.getDocumentElement();
	// 3):获取第二个联系人元素(linkman).
	Element linkmanEl = (Element)root.getElementsByTagName("linkman").item(1);
	// 4):获取linkman元素下的name子元素.
	Element nameEl = (Element)root.getElementsByTagName("name").item(0);
	// 5):获取name元素的文本内容.
	System.out.println(nameEl.getTextContent());
}

修改某个元素节点的主体内容：把第一个联系人的邮箱改掉

操作步骤：

1. 获取 Document 文档对象
2. 获取 XML 中的根元素 contacts
3. 获取第一个联系人元素 linkman
4. 获取 linkman 元素下的 email 子元素
5. 设置 email 元素的新的文本内容 will@
6. 同步操作：把内存中的数据同步更新到磁盘的XML中
   核心类：Transformer

// 需求2、修改某个元素节点的主体内容：把第一个联系人的邮箱改掉.
@Test
public void test2() throws Exception {
	// 1):获取Document文档对象.
	Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(f);
	// 2):获取XML中的根元素(contacts).
	Element root = doc.getDocumentElement();
	// 3):获取第一个联系人元素(linkman).
	Element linkmanEl = (Element)root.getElementsByTagName("linkman").item(0);
	// 4):获取linkman元素下的email子元素.
	Element emailEle = (Element)linkmanEl.getElementsByTagName("email").item(0);
	// 5):设置email元素的新的文本内容(will@).
	emailEle.setTextContent("will@");
	// 6):同步操作:把内存中的数据同步更新到磁盘的XML中.核心类:Transformer.
	TransformerFactory factory = TransformerFactory.newInstance();
	Transformer trans = factory.newTransformer();
	Source xmlSource = new DOMSource(doc); // 源: 内存中的Document对象
	Result outputTarget = new StreamResult(f); // 目标: 磁盘中的XML文件(contacts.xml)
	trans.transform(xmlSource, outputTarget); // 同步操作
}

向指定元素节点中增加子元素节点：增加一个新的联系人信息

操作步骤：

1. 获取 Document 文档对象
2. 获取XML中的根元素 contacts
3. 创建一个 linkman 元素的片段
   1. 创建 linkman、name、email、address、group 元素
   2. 给 name、email、address、group 元素设置文本内容
   3. 把 name、email、address、group 元素作为 linkman 元素的子元素
   4. 把 linkman 元素作为根元素的子元素
4. 同步操作：把内存中的数据同步更新到磁盘的XML中
   核心类：Transformer.

// 需求3,向指定元素节点中增加子元素节点：增加一个新的联系人信息.
@Test
public void test3() throws Exception {
	// 1):获取Document文档对象.
	Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(f);
	// 2):获取XML中的根元素(contacts).
	Element root = doc.getDocumentElement();
	// -----------------------------------------------------
	// 3):创建一个linkman元素的片段.
	// 3.1):创建linkman,name,email,address,group元素
	Element linkmanEl = doc.createElement("linkman");
	Element nameEl = doc.createElement("name");
	Element emailEl = doc.createElement("email");
	Element addressEl = doc.createElement("address");
	Element groupEl = doc.createElement("group");
	// 3.2):给name,email,address,group元素设置文本内容
	linkmanEl.setAttribute("id", "3"); // linkman设置id属性
	nameEl.setTextContent("yusael");
	emailEl.setTextContent("[email protected]");
	addressEl.setTextContent("苏州");
	groupEl.setTextContent("HELLO");
	// 3.3):把name,email,address,group元素作为linkman元素的子元素.  
	linkmanEl.appendChild(nameEl);
	linkmanEl.appendChild(emailEl);
	linkmanEl.appendChild(addressEl);
	linkmanEl.appendChild(groupEl);
	// 3.4):把linkman元素作为根元素的子元素
	root.appendChild(linkmanEl);
	// -----------------------------------------------------
	// 4):同步操作:把内存中的数据同步更新到磁盘的XML中.核心类:Transformer.
	TransformerFactory factory = TransformerFactory.newInstance();
	Transformer trans = factory.newTransformer();
	trans.transform(new DOMSource(doc), new StreamResult(f));
}

操作XML元素属性：设置/获取第三个联系人的id属性

操作步骤：

1. 获取 Document 文档对象
2. 获取XML中的根元素 contacts
3. 获取第三个联系人元素 linkman
4. 获取 linkman 元素下的 id 属性值 / 设置 linkman 元素的 id 属性值.
5. 同步操作：把内存中的数据同步更新到磁盘的XML中
   核心类：Transformer
   如果是获取属性，是不需要同步操作的；如果是设置属性需要同步操作。

// 需求4、操作XML元素属性：设置/获取第三个联系人的id属性.
@Test
public void test4() throws Exception {
	// 1):获取Document文档对象.
	Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(f);
	// 2):获取XML中的根元素(contacts).
	Element root = doc.getDocumentElement();
	// 3):获取第三个联系人元素(linkman).
	Element linkmanEl = (Element)root.getElementsByTagName("linkman").item(2);
	// -----------------------------------------------------
	// 4):获取linkman元素下的id属性/设置linkman元素的id属性值.
	linkmanEl.setAttribute("id", "3"); // 设置第3个人的id为3
	String id = linkmanEl.getAttribute("id"); // 获取第3个人的id
	// -----------------------------------------------------
	// 5):同步操作:把内存中的数据同步更新到磁盘的XML中.核心类:Transformer.
	TransformerFactory factory = TransformerFactory.newInstance();
	Transformer trans = factory.newTransformer();
	trans.transform(new DOMSource(doc), new StreamResult(f));
}

删除指定元素节点：删除第三个联系人信息.

操作步骤：

1. 获取 Document 文档对象
2. 获取XML中的根元素 contacts
3. 获取第三个联系人元素 linkman
4. 删除第三个 linkan 元素.(请自己的老爸来干掉自己)
5. 同步操作：把内存中的数据同步更新到磁盘的XML中
   核心类：Transformer

// 需求5、删除指定元素节点：删除第三个联系人信息.
@Test
public void test5() throws Exception {
	// 1):获取Document文档对象.
	Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(f);
	// 2):获取XML中的根元素(contacts).
	Element root = doc.getDocumentElement();
	// 3):获取第三个联系人元素(linkman).
	Element linkmanEl = (Element)root.getElementsByTagName("linkman").item(2);
	// -----------------------------------------------------
	// 4):删除第三个linkan元素.(请自己的老爸来干掉自己)
	// root.removeChild(linkmanEl);
	linkmanEl.getParentNode().removeChild(linkmanEl);
	// -----------------------------------------------------
	// 5):同步操作:把内存中的数据同步更新到磁盘的XML中.核心类:Transformer.
	TransformerFactory factory = TransformerFactory.newInstance();
	Transformer trans = factory.newTransformer();
	trans.transform(new DOMSource(doc), new StreamResult(f));
}

在内存中创建一个Document对象

// 需求6、在内存中创建一个Document对象。
@Test
public void test6() throws Exception {
	// 1):获取Document文档对象.
	DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
	Document doc = null;
	// 如果XML存在,则解析,否则创建新的
	if (f.exists()) {
		doc = builder.parse(f);
	} else {
		doc = builder.newDocument();
		// 创建根元素, 并把根元素作为文档的子元素
		doc.appendChild(doc.createElement("contacts"));
	}
	// 执行操作
	// ......
	
	// 同步操作
	// ......
}

DOM4J

dom4j 是一个 Java 的 XML API，是 jdom 的升级品，用来读写 XML 文件的。dom4j 是一个十分优秀的JavaXML API，具有性能优异、功能强大和极其易使用的特点，它的性能超过 sun 公司官方的 dom 技术，同时它也是一个开放源代码的软件，可以在 SourceForge 上找到它。在IBM developerWorks 上面还可以找到一篇文章，对主流的 Java XML API 进行的性能、功能和易用性的评测，所以可以知道dom4j无论在哪个方面都是非常出色的。如今可以看到越来越多的 Java 软件都在使用 dom4j 来读写 XML，特别值得一提的是连 Sun 的 JAXM 也在用 dom4j。这已经是必须使用的 jar包， Hibernate 也用它来读写配置文件。

简而言之：比官方的 DOM 更牛逼！ 以后操作 XML 使用这个就可以了，上面的 DOM 了解一下，会了 DOM，DOM4J 用起来更方便。

下面的示例就是一些很基础常用的 demo，体验一下，开发中还是要去看文档。

查询所有联系人的信息

import java.io.File;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.junit.Test;

public class DOM4JTest {
	private File f = new File("F:/java/JavasePro/JUnit-XML-DOM-DOM4J/contacts.xml");
	// 查询所有的联系人
	@Test
	public void testGetAll() throws Exception {
		// 获取文档对象
		SAXReader reader = new SAXReader();
		Document doc = reader.read(f);
		// 获取根元素
		Element root = doc.getRootElement();
		// 获取根元素下的所有linkman元素
		List<Element> linkemanElList = root.elements("linkman");
		for (Element linkmanEl : linkemanElList) {
			// 获取每一个linkman元素的name子元素的文本内容
			// Element nameEl = linkmanEl.element("name");
			// String name = nameEl.getText();
			String id = linkmanEl.attributeValue("id");
			String name = linkmanEl.elementText("name");
			String email = linkmanEl.elementText("email");
			String address = linkmanEl.elementText("address");
			String group = linkmanEl.elementText("group");
			System.out.println(id + "_" + name + "_" + email + "_" + address + "_" + group);
			System.out.println("------------------------------");
		}
	}
}

新增一个联系人的信息

@Test
public void test2() throws Exception {
	// 获取文档对象
	SAXReader reader = new SAXReader();
	Document doc = reader.read(f);
	// 获取根元素
	Element root = doc.getRootElement();
	
	// 创建linkman元素, 把linkman元素作为根元素的子元素
	Element linkmanEl = root.addElement("linkman").addAttribute("id", "4");
	// 创建name,email,address,group元素, 作为linkman子元素, 设置文本内容
	linkmanEl.addElement("name").setText("西门吹雪");
	linkmanEl.addElement("email").setText("西门@吹雪");
	linkmanEl.addElement("address").setText("万梅山庄");
	linkmanEl.addElement("group").setText("武侠");
	
	// 同步操作
	FileWriter out = new FileWriter(f);
	doc.write(out);
	out.close(); // 必须关闭流, 否则xml会变成空白
	
	// createCompactFormat: 压缩格式, 输出成一行
	// createPrettyPrint: 良好的输出格式
	
	// OutputFormat format = OutputFormat.createPrettyPrint();
	// XMLWriter writer = new XMLWriter(new FileWriter(f), format);
	// writer.write(doc);
	// writer.close();
}

总结

• 单元测试（JUnit）环境搭建，以及测试流程得清楚；
• XML 语法只要求能看懂（一般不会自己写），对约束（dtd、Schema）了解即可；
• DOM 还是挺重要的，因为 JS 操作 html 也是类似的；
  DOM4J 相当于 DOM 的升级版；
  开发中一般不会自己去写 XML，所以大致记得能干什么即可。