我们这里就是对单元测试有个简单认识，会简单利用 3 和 4 编写一些测试代码。
测试环境搭建：将 junit 的测试 jar，添加到该项目中。
使用 junit3.x（了解）
junit3.x 是 Java5 以前的测试方式。
测试步骤:
把 junit3.x 的测试 jar，添加到项目中； 定义一个测试类，并让该测试类继承 TestCase；
测试类的名字：XxxTest，Xxx 表示一个对象或者一个模块、组件。
在 EmployeeDAOTest 中编写测试方法；
方法是 public 修饰，无返回值、无参数的。
必须以 test 作为方法的前缀，Xxx 表示测试的功能名字。
public void testXxx() throws Exception {}
选择某一个测试方法，鼠标右键选择 [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 开始的版本，支持注解。
步骤:
把 junit4.x 的测试 jar，添加到项目中;； 定义一个测试类。（不再继承 TestCase 类）
测试类的名字: XxxTest
在 EmployeeDAOTest 中编写测试方法；
方法是 public 修饰的，无返回的；
该方法上必须贴有 @Test 标签，Xxx 表示测试的功能名字。
@Test
public void testXxx() throws Exception {}
选择某一个测试方法，鼠标右键选择 [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文档，且必须出现在文档的第一行。
最简单的语法，如：
用 encoding 属性说明文档所使用的字符编码，默认为 UTF-8。
保存在磁盘上的文件编码要与声明的编码一致。
如：
用 standalone 属性说明文档是否独立，即是否依赖其他文档。
如：
CDATA 是 Character Data 的缩写：
作用：把标签当做普通文本内容；
解析器不对 CDATA 区中的内容进行解析，而是将这些数据原封不动地交给程序去处理。
语法：
xml 一般情况下不会要求去写，大致看得懂即可。
Will
iwiller@qq.com
成都
叩丁狼教育
Stef
lanyotech@qq.com
成都
叩丁狼教育
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”);
得到某个具体的文本节点的内容：取出第二个联系人的名字
操作步骤：
获取 Document 文档对象 获取 XML 中的根元素 contacts 获取第二个联系人元素 linkman 获取 linkman 元素下的 name 子元素 获取 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());
}
修改某个元素节点的主体内容：把第一个联系人的邮箱改掉
操作步骤：
获取 Document 文档对象 获取 XML 中的根元素 contacts 获取第一个联系人元素 linkman 获取 linkman 元素下的 email 子元素 设置 email 元素的新的文本内容 will@ 同步操作：把内存中的数据同步更新到磁盘的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); // 同步操作
}
向指定元素节点中增加子元素节点：增加一个新的联系人信息
操作步骤：
获取 Document 文档对象 获取XML中的根元素 contacts 创建一个 linkman 元素的片段 创建 linkman、name、email、address、group 元素 给 name、email、address、group 元素设置文本内容 把 name、email、address、group 元素作为 linkman 元素的子元素 把 linkman 元素作为根元素的子元素 同步操作：把内存中的数据同步更新到磁盘的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(“yusael@qq.com”);
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属性
操作步骤：
获取 Document 文档对象 获取XML中的根元素 contacts 获取第三个联系人元素 linkman 获取 linkman 元素下的 id 属性值 / 设置 linkman 元素的 id 属性值. 同步操作：把内存中的数据同步更新到磁盘的XML中
核心类：Transformer
如果是获取属性，是不需要同步操作的；如果是设置属性需要同步操作。
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）
独家面经总结，超级精彩
本人面试腾讯，阿里，百度等企业总结下来的面试经历，都是真实的，分享给大家！
Java面试准备
准确的说这里又分为两部分：
Java刷题算法刷题
Java刷题：此份文档详细记录了千道面试题与详解；
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！ 往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**
因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-UzWJltU5-1713393211274)]
[外链图片转存中…(img-D74988jV-1713393211274)]
[外链图片转存中…(img-OmAj56pR-1713393211274)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）
独家面经总结，超级精彩
本人面试腾讯，阿里，百度等企业总结下来的面试经历，都是真实的，分享给大家！
[外链图片转存中…(img-181zL1FU-1713393211275)]
[外链图片转存中…(img-pi8Wt3R2-1713393211275)]
[外链图片转存中…(img-EDr9FMYV-1713393211275)]
[外链图片转存中…(img-KtV7gjf2-1713393211275)]
Java面试准备
准确的说这里又分为两部分：
Java刷题算法刷题
Java刷题：此份文档详细记录了千道面试题与详解；
[外链图片转存中…(img-wU4hcyjv-1713393211275)]
[外链图片转存中…(img-qPIjVYe2-1713393211276)]
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
相关文章
您阅读本篇文章共花了：
发表评论