JavaSE进阶15：XML、注解、JUnit单元测试

系列文章目录

JavaSE进阶01：继承、修饰符
JavaSE进阶02：多态、抽象类、接口
JavaSE进阶03：内部类、Lambda表达式
JavaSE进阶04：API中常用工具类
JavaSE进阶05：包装类、递归、数组的高级操作、异常
JavaSE进阶06：Collection集合、迭代器、List、ArrayList、LinkedList
JavaSE进阶07：泛型、Set集合、TreeSet、二叉树、红黑树
JavaSE进阶08：HashSet、Map集合、HashMap、TreeMap、可变参数、不可变集合
JavaSE进阶09：Stream流、File类
JavaSE进阶10：IO流、字节流、字节缓冲流
JavaSE进阶11：字符流、字符缓冲流、转换流、对象操作流、Properties集合
JavaSE进阶12：多线程、线程同步、线程池
JavaSE进阶13：网络编程入门、UDP通信程序、TCP通信程序、日志、枚举
JavaSE进阶14：类加载器、反射
JavaSE进阶15：XML、注解、JUnit单元测试
JavaSE进阶扩充：JDK8 HashMap底层分析（了解）
JavaSE进阶扩充：JDK8 ArrayList线程安全问题和源码分析、集合常见面试题
Java进阶作业

---

---

1.XML

1.1概述【理解】

• 万维网联盟(W3C)创建于1994年，又称W3C理事会。1994年10月在麻省理工学院计算机科学实验室成立。建立者： Tim Berners-Lee (蒂姆·伯纳斯·李)。W3C是Web技术领域最具权威和影响力的国际中立性技术标准机构

• 到目前为止，W3C已发布了200多项影响深远的Web技术标准及实施指南。如广为业界采用的超文本标记语言HTML（标准通用标记语言下的一个应用）。可扩展标记语言XML（标准通用标记语言下的一个子集）。 以及帮助残障人士有效获得Web信息的无障碍指南（WCAG）等

• w3school网站

  • https://www.w3school.com.cn，会像API一样经常打开。

• XML概述

  • XML的全称为(EXtensible Markup Language)，是一种可扩展的标记语言
  • 标记语言: 通过标签来描述数据的一门语言(标签有时我们也将其称之为元素)
  • 可扩展：标签的名字是可以自定义的,XML文件是由很多标签组成的,而标签名是可以自定义的

• 作用

  • 用于进行存储数据和传输数据
  • 作为软件的配置文件

• 作为配置文件的优势

  • 可读性好
  • 可维护性高

1.2标签的规则【应用】

• 标签由一对尖括号和合法标识符组成

<student>

• 标签必须成对出现

<student> student>
前边的是开始标签，后边的是结束标签

• 特殊的标签可以不成对,但是必须有结束标记

<address/>

• 标签中可以定义属性,属性和标签名空格隔开,属性值必须用引号引起来

<student id="1"> student>

• 标签需要正确的嵌套

这是正确的: <student id="1"><name>张三name> student>
这是错误的: <student id="1"><name>张三student>name>

1.3语法规则【应用】

• 语法规则

  • XML文件的后缀名为：xml

  • 文档声明必须是第一行第一列

 version：该属性是必须存在的，固定值1.0
 encoding：该属性不是必须的，打开当前xml文件的时候应该是使用什么字符编码表(一般取值都是UTF-8)
 standalone: 该属性不是必须的，描述XML文件是否依赖其他的xml文件，取值为yes/no

• 必须存在一个根标签，有且只能有一个

• XML文件中可以定义注释信息

• XML文件中可以存在以下特殊字符

    < < 小于
    > > 大于
    & & 和号
    ' ' 单引号
    " " 引号

• XML文件中可以存在CDATA区

• 示例代码

<students>
    
    <student id="1">
        <name>张三name>
        <age>23age>
        <info>'学生'<>&的" 信息" info>
        <message> &的"信息" ]]]>message>
    student>
    
    <student id="2">
        <name>李四name>
        <age>24age>
    student>
students>

正确时，浏览器打开不报错或IDEA不标红

1.4xml解析【应用】

• 概述

  xml解析就是从xml中获取到数据

• 常见的解析思想

  DOM(Document Object Model)文档对象模型:就是把文档的各个组成部分看做成对应的对象。
  会把xml文件全部加载到内存,在内存中形成一个树形结构,再获取对应的值

• 常见的解析工具

  • JAXP: SUN公司提供的一套XML的解析的API
  • JDOM: 开源组织提供了一套XML的解析的API-jdom
  • DOM4J: 开源组织提供了一套XML的解析的API-dom4j,全称：Dom For Java
  • pull: 主要应用在Android手机端解析XML

• 解析的准备工作

  1. 我们可以通过网站：https://dom4j.github.io/ 去下载dom4j

  2. 将dom4j-1.6.1.zip解压,找到里面的dom4j-1.6.1.jar

  3. 在idea中当前模块下新建一个libs文件夹,将jar包复制到文件夹中

  4. 选中jar包 -> 右键 -> 选择add as library即可

• 需求

  • 解析提供好的xml文件
  • 将解析到的数据封装到学生对象中
  • 并将学生对象存储到ArrayList集合中
  • 遍历集合

• 代码实现

/*myxml\\xml\\student.xml*/
<?xml version="1.0" encoding="UTF-8" ?>
<!--注释的内容-->
<!--本xml文件用来描述多个学生信息-->
<students>

    <!--第一个学生信息-->
    <student id="1">
        <name>张三</name>
        <age>23</age>
    </student>

    <!--第二个学生信息-->
    <student id="2">
        <name>李四</name>
        <age>24</age>
    </student>
	
	<aaa></aaa>
</students>
  
/*学生类*/
public class Student {
    private String id;
    private String name;
    private int age;

    public Student() {
    }

    public Student(String id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
  
/**
 * 利用dom4j解析xml文件
 */
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import java.io.File;
import java.util.ArrayList;
import java.util.List;

public class XmlParse {
    public static void main(String[] args) throws DocumentException {
        //1.获取一个解析器对象
        SAXReader saxReader = new SAXReader();
        //2.利用解析器把xml文件加载到内存中,并返回一个文档对象
        Document document = saxReader.read(new File("MyXML\\xml\\student.xml"));
        //3.获取到根标签
        Element rootElement = document.getRootElement();
        //4.通过根标签来获取student标签
        //elements():可以获取调用者所有的子标签.会把这些子标签放到一个集合中返回.
        //elements("标签名"):可以获取调用者所有的指定的子标签,

        //List list = rootElement.elements();
        //System.out.println(list.size());//输出3，因为xml中有2个student标签和1个aaa标签

        List<Element> studentElements = rootElement.elements("student");//只获取student标签


        //用来装学生对象
        ArrayList<Student> list = new ArrayList<>();

        //5.遍历集合,得到每一个student标签
        for (Element element : studentElements) {
            //element依次表示每一个student标签

            //获取id这个属性
            Attribute attribute = element.attribute("id");
            //获取id的属性值
            String id = attribute.getValue();

            //获取name标签
            //element("标签名"):获取调用者指定的子标签
            Element nameElement = element.element("name");
            //获取这个标签的标签体内容
            String name = nameElement.getText();

            //获取age标签
            Element ageElement = element.element("age");
            //获取age标签的标签体内容
            String age = ageElement.getText();

            //封装加入集合
            Student s = new Student(id,name,Integer.parseInt(age));
            list.add(s);
        }
        //遍历操作
        for (Student student : list) {
            System.out.println(student);
        }
    }
}

/*
Student{id='1', name='张三', age=23}
Student{id='2', name='李四', age=24}
*/

1.5约束【几乎用不到】

1.5.1约束概述

• 什么是约束

  • 用来限定xml文件中可使用的标签以及属性

• 约束的分类

  • DTD
  • schema

• 编写DTD约束

  • 步骤

    1. 创建一个文件，这个文件的后缀名为.dtd

    2. 看xml文件中使用了哪些元素

       可以定义元素

    3. 判断元素是简单元素还是复杂元素
       简单元素：没有子元素。
       复杂元素：有子元素的元素；

1.5.2DTD约束

• 引入DTD约束

  • 引入DTD约束的三种方法

    • 引入本地dtd

    • 在xml文件内部引入

    • 引入网络dtd

  • 代码实现

    • 引入本地DTD约束

    
    DOCTYPE persons SYSTEM 'persondtd.dtd'>
    
    <persons>
        <person>
            <name>张三name>
            <age>23age>
        person>
        
    
    persons>
    

    • 在xml文件内部引入

    
    DOCTYPE persons [
            <!ELEMENT persons (person)>
            <!ELEMENT person (name,age)>
            <!ELEMENT name (#PCDATA)>
            <!ELEMENT age (#PCDATA)>
            ]>
    
    <persons>
        <person>
            <name>张三name>
            <age>23age>
        person>
    persons>
    

    • 引入网络dtd

    
    DOCTYPE persons PUBLIC "dtd文件的名称" "dtd文档的URL">
    
    <persons>
        <person>
            <name>张三name>
            <age>23age>
        person>
    persons>
    

• DTD语法

  • 定义元素

    • 定义一个元素的格式为：
    • 简单元素：
      ​ EMPTY: 表示标签体为空
      ​ ANY: 表示标签体可以为空也可以不为空
      ​ PCDATA: 表示该元素的内容部分为字符串，最常用
    • 复杂元素：直接写子元素名称.
      多个子元素可以使用",“或者”|"隔开；
      ​ ","表示定义子元素的顺序 ; “|”: 表示子元素只能出现任意一个
      ​ "?"零次或一次, "+"一次或多次, "*"零次或多次;如果不写则表示只能出现一次

  • 定义属性

    • 格式
      定义一个属性的格式为：
    • 属性的类型：
      ​ CDATA类型：普通的字符串
    • 属性的约束:
      ​ #REQUIRED： 必须的
      ​ #IMPLIED： 属性不是必需的
      ​ #FIXED value：属性值是固定的

  • 代码实现

    
    <!ELEMENT persons (person+)>
    <!ELEMENT person (name,age)>
    <!ELEMENT name (#PCDATA)>
    <!ELEMENT age (#PCDATA)>
    <!ATTLIST person id CDATA #REQUIRED>
    
    
    
    DOCTYPE persons SYSTEM 'persondtd.dtd'>
    <persons>
        <person id="001">
            <name>张三name>
            <age>23age>
        person>
    	
    	
        <person id = "002">
            <name>张三name>
            <age>23age>
        person>
    
    persons>
    

1.5.3schema约束

• schema和dtd的区别

1. schema约束文件也是一个xml文件，符合xml的语法，这个文件的后缀名.xsd
2. 一个xml中可以引用多个schema约束文件，多个schema使用名称空间区分（名称空间类似于java包名）
3. dtd里面元素类型的取值比较单一常见的是PCDATA类型，但是在schema里面可以支持很多个数据类型
4. schema 语法更加的复杂
   

• 编写schema约束

  • 步骤
    

  • 代码实现

    
    <schema
        xmlns="http://www.w3.org/2001/XMLSchema"
        targetNamespace="http://www.xxx.com/javase"
        elementFormDefault="qualified"
    >
    
        
        <element name="persons">
            <complexType>
                <sequence>
                    
                    <element name = "person">
                        <complexType>
                            <sequence>
                                
                                <element name = "name" type = "string">element>
                                <element name = "age" type = "string">element>
                            sequence>                 
                        complexType>
                    element>
                sequence>
            complexType>   
        element>
    
    schema> 
    

• 引入schema约束

  • 步骤
    

  • 代码实现

    <?xml version="1.0" encoding="UTF-8" ?>
    
    <persons
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns="http://www.xxx.com/javase"
        xsi:schemaLocation="http://www.xxx.com/javase MyXML/xml/person.xsd"
    >
        <person>
            <name>张三</name>
            <age>23</age>
        </person>
    
    </persons>
    ​```
    

• schema约束定义属性

  • 代码示例

    
    
    <schema
        xmlns="http://www.w3.org/2001/XMLSchema"
        targetNamespace="http://www.xxx.com/javase"
        elementFormDefault="qualified"
    >
    
        
        <element name="persons">
            <complexType>
                <sequence>
                    
                    <element name = "person">
                        <complexType>
                            <sequence>
                                
                                <element name = "name" type = "string">element>
                                <element name = "age" type = "string">element>
                            sequence>
                            
                            
                            <attribute name="id" type="string" use="required">attribute>
                        complexType>
                        
                    element>
                sequence>
            complexType>
        element>
    schema>
    
    
    
    <persons
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns="http://www.itheima.cn/javase"
        xsi:schemaLocation="http://www.itheima.cn/javase person.xsd"
    >
        <person id="001">
            <name>张三name>
            <age>23age>
        person>
    persons>
    

2.注解

2.1概述【理解】

• 注解概述：对我们的程序进行标注和解释

• 注解和注释的区别

  • 注释: 给程序员看的
  • 注解: 给编译器看的

• 使用注解进行配置配置的优势：代码更加简洁、方便

• 注解分类

注解名	说明
@Override	描述子类重写父类的方法
@Deprecated	描述方法过时
@SuppressWarnings	压制警告

2.2自定义注解【理解】

• 格式

  public @interface 注解名称 {
  ​	public 属性类型 属性名() default 默认值 ;
  }
  

• 属性类型

  • 基本数据类型
  • String
  • Class
  • 注解
  • 枚举
  • 以上类型的一维数组

• 代码演示

/*注解类*/
public @interface Anno2 {
}
/*枚举类*/
public enum Season {
    SPRING,SUMMER,AUTUMN,WINTER;
}
/*注解类Anno1 */
public @interface Anno1 {

    //定义一个基本类型的属性
    public int a() default 23;

    //定义一个String类型的属性
    //public String name();

    //定已一个Class类型的属性
    public Class clazz() default Anno2.class;

    //定义一个注解类型的属性
    public Anno2 anno() default @Anno2;

    //定义一个枚举类型的属性
    public Season season() default Season.SPRING;

    //以上类型的一维数组
    //如：int数组
    public int[] arr() default {1,2,3,4,5};
    //如：枚举数组
    public Season[] seasons() default {Season.SPRING,Season.SUMMER};

    //value当后期我们在使用注解的时候，如果我们只需要给注解的value属性赋值，那么value=就可以省略
    public String value();
}

/*枚举测试类*/

//在使用注解的时候如果注解里面的属性没有指定默认值,那么我们就需要手动给出注解属性的设置值。
//@Anno1(name="123",value="abc")
@Anno1("abc")//只需要给注解的value属性赋值时，那么value=就可以省略 ,只有value这个单词可以
public class AnnoDemo {
}

• 自定义注解案例

  • 需求

    自定义一个注解@Test,用于指定类的方法上,如果某一个类的方法上使用了该注解,就执行该方法

  • 实现步骤

    1. 自定义一个注解Test,并在类中的某几个方法上加上注解
    2. 在测试类中,获取注解所在的类的Class对象
    3. 获取类中所有的方法对象
    4. 遍历每一个方法对象,判断是否有对应的注解

  • 代码实现

    /*注解类*/
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    @Retention(value = RetentionPolicy.RUNTIME)//此为元注解：表示Test这个注解的存活时间
    public @interface Test {
    }
    
    /*对象类*/
    public class UseTest {
        //没有使用Test注解
        public void show(){
            System.out.println("UseTest....show....");
        }
        //使用Test注解
        @Test
        public void method(){
            System.out.println("UseTest....method....");
        }
        //没有使用Test注解
        public void function(){
            System.out.println("UseTest....function....");
        }
    }
    
    /*测试类*/
    import java.lang.reflect.Constructor;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    public class AnnoDemo2 {
        public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchMethodException {
            //1.通过反射获取UseTest类的字节码文件对象
            Class clazz = Class.forName("UseTest");
    
            //创建对象
            Constructor constructor = clazz.getConstructor();
            UseTest useTest = (UseTest) constructor.newInstance();
    
            //2.通过反射获取这个类里面所有的方法对象
            Method[] methods = clazz.getDeclaredMethods();
    
            //3.遍历数组，得到每一个方法对象
            for (Method method : methods) {//method依次表示每一个方法对象。
                //isAnnotationPresent(Class annotationClass)
                //判断当前方法上是否有指定的注解。
                //参数：注解的字节码文件对象
                //返回值：布尔结果。  true 存在  false 不存在
                if(method.isAnnotationPresent(Test.class)){
                    method.invoke(useTest);//invoke执行方法需要调用者
                }
            }
        }
    }
    /*
    UseTest....method....
     */
    

2.3元注解【理解】

• 概述

  元注解就是描述注解的注解

• 元注解介绍

  元注解名	说明
  @Target	指定了注解能在哪里使用
  @Retention	可以理解为保留时间(生命周期)
  @Inherited	表示修饰的自定义注解可以被子类继承
  @Documented	表示该自定义注解，会出现在API文档里面。

/*注解类*/
import java.lang.annotation.*;
@Target({ElementType.FIELD,ElementType.TYPE,ElementType.METHOD})  //指定注解使用的位置（成员变量，类，方法）
@Retention(RetentionPolicy.RUNTIME) //指定该注解的存活时间，若不写该注解只能存活在源码阶段即java文件时存在，class文件就不存在了
@Inherited //指定该注解可以被继承
public @interface Anno3 {
}

/*人类*/
@Anno3
public class Person {
}

/*学生类*/
public class Student extends Person{
    public void show(){
        System.out.println("student.......show..........");
    }
}

/*测试类*/
public class StudentDemo {
    public static void main(String[] args) throws ClassNotFoundException {
        //获取到Student类的字节码文件对象
        Class clazz1 = Class.forName("Person");
        Class clazz2 = Class.forName("Student");

        //获取注解，判断class是否有注解
        boolean result1 = clazz1.isAnnotationPresent(Anno3.class);
        boolean result2 = clazz2.isAnnotationPresent(Anno3.class);
        System.out.println("Person："+result1);
        System.out.println("Student："+result2);
    }
}
/*
Person：true
Student：true
 */

都为true表示Student类已经继承了父类Person的注解Anno3。

3.JUnit单元测试

3.1概述【理解】

JUnit是一个 Java 编程语言的单元测试工具，JUnit 是一个非常重要的测试工具。

3.2特点【理解】

• JUnit是一个开放源代码的测试工具。
• 提供注解来识别测试方法。
• JUnit测试可以让你编写代码更快，并能提高质量。
• JUnit优雅简洁。没那么复杂，花费时间较少。
• JUnit在一个条中显示进度。如果运行良好则是绿色；如果运行失败则变成红色。

3.3使用步骤【应用】

• 下载JUnit4

  • JUnit4下载官网，下载junit.jar

• 使用步骤

  1. 将junit的jar包导入到工程中 junit-4.9.jar
  2. 编写测试方法该测试方法必须是公共的无参数无返回值的非静态方法
  3. 在测试方法上使用==@Test==注解标注该方法是一个测试方法
  4. 选中测试方法右键通过junit运行该方法

• 代码示例

import org.junit.Test;
public class JUnitDemo1 {
    @Test
    public void add() {
        System.out.println(2 / 0);
        int a = 10;
        int b = 20;
        int sum = a + b;
        System.out.println(sum);
    }
}

此时会发现IDEA的方法可以直接测试，不再不需要创建main()方法测试。

3.4常用注解【应用】

• 注解说明

  注解	含义
  @Test	表示测试该方法
  @Before	在测试的方法前运行
  @After	在测试的方法后运行

import org.junit.After;
import org.junit.Test;
import org.junit.Before;
public class JunitDemo2 {
    @Before
    public void before() {
        // 在执行测试代码之前执行，一般用于初始化操作
        System.out.println("before");
    }
    @Test
    public void test() {
        // 要执行的测试代码
        System.out.println("test");
    }
    @After
    public void after() {
        // 在执行测试代码之后执行，一般用于释放资源
        System.out.println("after");
    }
}
/*
before
test
after
 */

3.5单元测试与主方法相对路径问题【应用】

总结：单元测试会默认给File路径加上 模块名

package com.xxx.driud;

import org.junit.Test;
import java.io.File;

public class TestDemo {

    public static void main(String[] args) {
        File file=new File("MyModule\\src\\druid.properties");
        System.out.print("main方法绝对路径1：");
        System.out.println(file.getAbsolutePath());
        System.out.print("main方法绝对路径2：");
        new TestDemo().unitTesting();

    }

    @Test
    public void unitTesting(){
        File file=new File("MyModule\\src\\druid.properties");
        System.out.println(file.getAbsolutePath());
    }
}
/*
main方法绝对路径1：D:\AAAAA\IDEAWorkSpace\MyProject\MyModule\src\druid.properties
main方法绝对路径2：D:\AAAAA\IDEAWorkSpace\MyProject\MyModule\src\druid.properties

单元测试输出：D:\AAAAA\IDEAWorkSpace\MyProject\MyModule\MyModule\src\druid.properties
 */