Junit、反射、注解、XML
第1章 Junit单元测试
- 测试分类:
- 黑盒测试:不需要写代码,给输入值,看程序是否能够输出期望的值。
- 白盒测试:需要写代码的。关注程序具体的执行流程。
1.1 Junit介绍
Junit是一个Java语言的单元测试框架,属于白盒测试,简单理解为可以用于(部分)取代java的main方法。Junit属于第三方工具,需要导入jar包后使用。
1.2 Junit的使用
- 编写测试类,简单理解Junit可以用于取代java的main方法
- 在测试类方法上添加注解 @Test
- @Test修饰的方法要求:public void 方法名() {…} ,方法名自定义建议test开头,没有参数。
- 添加Junit库到lib文件夹中,然后进行jar包关联
- 使用:点击方法左侧绿色箭头,执行当前方法(方法必须标记@Test)。执行结果红色:代表失败;执行结果绿色:代表成功
1.3 常用注解
- @Test,用于修饰需要执行的测试方法
- @Before,修饰的方法会在测试方法之前被自动执行
- @After,修饰的方法会在测试方法执行之后自动被执行
第2章 反射:框架设计的灵魂
- 框架:半成品软件。可以在框架的基础上进行软件开发,简化编码
- 反射:将java代码的各个组成部分封装为其他对象,可以在程序运行过程中操作这些对象,这就是java的反射机制,如下图。
- 反射的好处:
- 可以在程序运行过程中,操作这些对象。
- 可以解耦,提高程序的可扩展性。
2.1 获取Class对象的方式
获取class对象方式 | 作用 | 应用场景 |
---|---|---|
Class.forName(“全类名”) | 通过指定的字符串路径获取 | 多用于配置文件,将类名定义在配置文件中。读取文件,加载类 |
类名.class | 通过类名的属性class获取 | 多用于参数的传递 |
对象.getClass() | 通过对象的getClass()方法获取 | 多用于对象的获取字节码的方式 |
提示:同一个字节码文件(*.class)在一次程序运行过程中,只会被加载一次,不论通过哪一种方式获取的Class对象都是同一个。
2.2 获取Class对象的信息
知道怎么获取Class对象之后,接下来就介绍几个Class类中常用的方法了。
Class对象相关方法
-
String getSimpleName(); 获得简单类名,只是类名,没有包
-
String getName(); 获取完整类名,包含包名+类名
-
T newInstance() ;创建此 Class 对象所表示的类的一个新实例。要求:类必须有public的无参数构造方法
编写代码演示:
1.获取简单类名、获取完成类名
2.创建对象
2.3 Constructor类
Constructor是构造方法类,类中的每一个构造方法都是Constructor的对象,通过Constructor对象可以实例化对象。
Class类中与Constructor相关方法
1. Constructor getConstructor(Class... parameterTypes)
根据参数类型获取构造方法对象,只能获得public修饰的构造方法。
如果不存在对应的构造方法,则会抛出 java.lang.NoSuchMethodException 异常。
2. Constructor getDeclaredConstructor(Class... parameterTypes)
根据参数类型获取构造方法对象,包括private修饰的构造方法。
如果不存在对应的构造方法,则会抛出 java.lang.NoSuchMethodException 异常。
3. Constructor[] getConstructors()
获取所有的public修饰的构造方法
4. Constructor[] getDeclaredConstructors()
获取所有构造方法,包括privat修饰的
Constructor类中常用方法
1. T newInstance(Object... initargs)
根据指定参数创建对象。
2. void setAccessible(true) 去除私有权限
暴力反射,设置为可以直接访问私有类型的构造方法。
编写代码演示
2.4 Method类
Method是方法类,类中的每一个方法都是Method的对象,通过Method对象可以调用方法。
Class类中与Method相关方法
1. Method getMethod("方法名", 方法的参数类型... 类型)
根据方法名和参数类型获得一个方法对象,只能是获取public修饰的
2. Method getDeclaredMethod("方法名", 方法的参数类型... 类型)
根据方法名和参数类型获得一个方法对象,包括private修饰的
3. Method[] getMethods()
获取所有的public修饰的成员方法,包括父类中。
4. Method[] getDeclaredMethods()
获取当前类中所有的方法,包含私有的,不包括父类中。
Method类中常用方法
1. Object invoke(Object obj, Object... args)
根据参数args调用对象obj的该成员方法
如果obj=null,则表示该方法是静态方法
2. void setAccessible(boolean flag)
暴力反射,设置为可以直接调用私有修饰的成员方法
编写代码演示
2.5 反射案例
需求:写一个"框架",不能改变该类的任何代码的前提下,可以帮我们创建任意类的对象,并且执行其中任意方法
实现:
- 配置文件
- 反射
步骤:
- 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
- 在程序中加载读取配置文件
- 使用反射技术来加载类文件进内存
- 创建对象
- 执行方法
编写代码演示
pro.properties
className=com.itheima.domain.Student
methodName=sleep
Student.java
package com.itheima.domain;
public class Student {
public void sleep(){
System.out.println("sleep...");
}
}
RefectTest.java
public class ReflectTest {
@Test
public void test() throws Exception {
//可以创建任意类的对象,可以执行任意方法
//前提:不能改变该类的任何代码。可以创建任意类的对象,可以执行任意方法
//1.加载配置文件
//1.1创建Properties对象
Properties pro = new Properties();
//1.2加载配置文件,转换为一个集合
//1.2.1获取class目录下的配置文件
ClassLoader classLoader = ReflectTest.class.getClassLoader();
InputStream is = classLoader.getResourceAsStream("pro.properties");
pro.load(is);
//2.获取配置文件中定义的数据
String className = pro.getProperty("className");
String methodName = pro.getProperty("methodName");
//3.加载该类进内存
Class cls = Class.forName(className);
//4.创建对象
Object obj = cls.newInstance();
//5.获取方法对象
Method method = cls.getMethod(methodName);
//6.执行方法
method.invoke(obj);
}
}
第3章 注解
定义:注解(Annotation),也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性,与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面,用来对这些元素进行说明,注释。
注释:给程序员阅读的
注解:给JVM看的
作用分类:
- 编写文档:通过代码里标识的注解生成文档【例如,生成文档doc文档】
- 代码分析:通过代码里标识的注解对代码进行分析【例如,注解的反射】
- 编译检查:通过代码里标识的注解让编译器能够实现基本的编译检查【例如,Override】
常见注解
- @author:用来标识作者名
- @version:用于标识对象的版本号,适用范围:文件、类、方法。
- @Override :用来修饰方法声明,告诉编译器该方法是重写父类中的方法,如果父类不存在该方法,则编译失败。
3.2 自定义注解
定义格式
元注解
public @interface 注解名称{
属性列表;
}
- 注解本质上就是一个接口,该接口默认继承Annotation接口
public interface MyAnno extends java.lang.annotation.Annotation {}
注解的属性
-
属性的作用
- 可以让用户在使用注解时传递参数,让注解的功能更加强大。
-
属性的格式
- 格式1:数据类型 属性名();
- 格式2:数据类型 属性名() default 默认值;
-
属性定义示例
public @interface Student { String name(); // 姓名 int age() default 18; // 年龄 String gender() default "男"; // 性别 } // 该注解就有了三个属性:name,age,gender
-
属性适用的数据类型
- 八种基本数据类型(int,float,boolean,byte,double,char,long,short)
- String类型,Class类型,枚举类型,注解类型
- 以上所有类型的一维数组
3.3 使用自定义注解
@注解名(属性名=属性值,属性名=属性值,属性名=属性值...)
定义注解
-
定义一个注解:Book
- 包含属性:String name() 书名
- 包含属性:double price() 价格,默认值为 100
- 包含属性:String[] authors() 多位作者
-
代码实现
public @interface Book { // 书名 String value(); // 价格 double price() default 100; // 多位作者 String[] authors(); }
使用注解
-
定义类在成员方法上使用Book注解
/** * @author itheima * @version 1.0 */ public class BookShelf { @Book(value = "西游记",price = 998,authors = {"吴承恩","白求恩"}) public void showBook(){ } }
-
使用注意事项
- 如果属性有默认值,则使用注解的时候,这个属性可以不用赋值。
- 如果属性没有默认值,那么在使用注解时一定要给属性赋值。
特殊属性value
- 当注解中只有一个属性且名称是value,在使用注解时给value属性赋值可以直接给属性值,无论value是单值元素还是数组类型。
// 定义注解Book
public @interface Book {
// 书名
String value();
}
// 使用注解Book
public class BookShelf {
@Book("西游记")
public void showBook(){
}
}
或
public class BookShelf {
@Book(value="西游记")
public void showBook(){
}
}
- 如果注解中除了value属性还有其他属性,且至少有一个属性没有默认值,则在使用注解给属性赋值时,value属性名不能省略。
// 定义注解Book
public @interface Book {
// 书名
String value();
// 价格
double price() default 100;
// 多位作者
String[] authors();
}
// 使用Book注解:正确方式
@Book(value="红楼梦",authors = "曹雪芹")
public class BookShelf {
// 使用Book注解:正确方式
@Book(value="西游记",authors = {"吴承恩","白求恩"})
public void showBook(){
}
}
// 使用Book注解:错误方式
public class BookShelf {
@Book("西游记",authors = {"吴承恩","白求恩"})
public void showBook(){
}
}
// 此时value属性名不能省略了。
3.4 注解之元注解
默认情况下,注解可以用在任何地方,比如类,成员方法,构造方法,成员变量等地方。如果要限制注解的使用位置怎么办?那就要学习一个新的知识点**:元注解**。
- @Target
- @Retention
元注解之@Target
- 作用:指明此注解用在哪个位置,如果不写默认是任何地方都可以使用。
- 可选的参数值在枚举类ElemenetType中包括:
TYPE: 用在类,接口上
FIELD:用在成员变量上
METHOD: 用在方法上
PARAMETER:用在参数上
CONSTRUCTOR:用在构造方法上
LOCAL_VARIABLE:用在局部变量上
元注解之@Retention
- 作用:定义该注解的生命周期(有效范围)。
- 可选的参数值在枚举类型RetentionPolicy中包括
SOURCE:注解只存在于Java源代码中,编译生成的字节码文件中就不存在了。
CLASS:注解存在于Java源代码、编译以后的字节码文件中,运行的时候内存中没有,默认值。
RUNTIME:注解存在于Java源代码中、编译以后的字节码文件中、运行时内存中,程序可以通过反射获取该注解。
元注解使用示例
@Target({ElementType.METHOD,ElementType.TYPE})
@interface Stu{
String name();
}
// 类
@Stu(name="jack")
public class AnnotationDemo02 {
// 成员变量
@Stu(name = "lily") // 编译失败
private String gender;
// 成员方法
@Stu(name="rose")
public void test(){
}
// 构造方法
@Stu(name="lucy") // 编译失败
public AnnotationDemo02(){}
}
3.5 注解解析
什么是注解解析
通过Java技术获取注解数据的过程则称为注解解析。
与注解解析相关的接口
- Anontation:所有注解类型的公共接口,类似所有类的父类是Object。
- java.lang.reflect.AnnotatedElement:定义了与注解解析相关的方法,常用方法以下四个:
boolean isAnnotationPresent(Class annotationClass); 判断当前对象是否有指定的注解,有则返回true,否则返回false。
T getAnnotation(Class<T> annotationClass); 获得当前对象上指定的注解对象。
Annotation[] getAnnotations(); 获得当前对象及其从父类上继承的所有的注解对象。
Annotation[] getDeclaredAnnotations();获得当前对象上所有的注解对象,不包括父类的。
获取注解数据的原理
注解作用在那个成员上,就通过反射获得该成员的对象来得到它的注解。
-
如注解作用在方法上,就通过方法(Method)对象得到它的注解
// 得到方法对象 Method method = clazz.getDeclaredMethod("方法名"); // 根据注解名得到方法上的注解对象 Book book = method.getAnnotation(Book.class);
-
如注解作用在类上,就通过Class对象得到它的注解
// 获得Class对象 Class c = 类名.class; // 根据注解的Class获得使用在类上的注解对象 Book book = c.getAnnotation(Book.class);
使用反射获取注解的数据
需求说明
- 定义注解Book,要求如下:
- 包含属性:String value() 书名
- 包含属性:double price() 价格,默认值为 100
- 包含属性:String[] authors() 多位作者
- 限制注解使用的位置:类和成员方法上
- 指定注解的有效范围:RUNTIME
- 定义BookStore类,在类和成员方法上使用Book注解
- 定义TestAnnotation测试类获取Book注解上的数据
代码实现
注解Book
@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Book {
// 书名
String value();
// 价格
double price() default 100;
// 作者
String[] authors();
}
BookStore类
@Book(value = "红楼梦",authors = "曹雪芹",price = 998)
public class BookStore {
@Book(value = "西游记",authors = "吴承恩")
public void buyBook(){
}
}
TestAnnotation类
public class TestAnnotation {
public static void main(String[] args) throws Exception{
System.out.println("---------获取类上注解的数据----------");
test01();
System.out.println("---------获取成员方法上注解的数据----------");
test02();
}
/**
* 获取BookStore类上使用的Book注解数据
*/
public static void test01(){
// 获得BookStore类对应的Class对象
Class c = BookStore.class;
// 判断BookStore类是否使用了Book注解
if(c.isAnnotationPresent(Book.class)) {
// 根据注解Class对象获取注解对象
Book book = (Book) c.getAnnotation(Book.class);
// 输出book注解属性值
System.out.println("书名:" + book.value());
System.out.println("价格:" + book.price());
System.out.println("作者:" + Arrays.toString(book.authors()));
}
}
/**
* 获取BookStore类成员方法buyBook使用的Book注解数据
*/
public static void test02() throws Exception{
// 获得BookStore类对应的Class对象
Class c = BookStore.class;
// 获得成员方法buyBook对应的Method对象
Method m = c.getMethod("buyBook");
// 判断成员方法buyBook上是否使用了Book注解
if(m.isAnnotationPresent(Book.class)) {
// 根据注解Class对象获取注解对象
Book book = (Book) m.getAnnotation(Book.class);
// 输出book注解属性值
System.out.println("书名:" + book.value());
System.out.println("价格:" + book.price());
System.out.println("作者:" + Arrays.toString(book.authors()));
}
}
}
3.6 注解案例
案例说明
模拟Junit测试的@Test
案例分析
- 模拟Junit测试的注释@Test,首先需要编写自定义注解@MyTest,并添加元注解,保证自定义注解只能修饰方法,且在运行时可以获得。
- 然后编写目标类(测试类),然后给目标方法(测试方法)使用 @MyTest注解,编写三个方法,其中两个加上@MyTest注解。
- 最后编写调用类,使用main方法调用目标类,模拟Junit的运行,只要有@MyTest注释的方法都会运行。
案例代码
注解MyTest
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyTest {
}
目标类MyTestDemo
public class MyTestDemo {
@MyTest
public void test01(){
System.out.println("test01");
}
public void test02(){
System.out.println("test02");
}
@MyTest
public void test03(){
System.out.println("test03");
}
}
调用类TestMyTest
public class TestMyTest {
public static void main(String[] args) throws Exception{
// 获得MyTestDemo类Class对象
Class c = MyTestDemo.class;
// 获得所有的成员方法对象
Method[] methods = c.getMethods();
// 创建MyTestDemo类对象
Object obj = c.newInstance();
// 遍历数组
for (Method m:methods) {
// 判断方法m上是否使用注解MyTest
if(m.isAnnotationPresent(MyTest.class)){
// 执行方法m
m.invoke(obj);
}
}
}
}
第四章 xml
4.1 xml概述
什么是XML
-
XML :可扩展标记语言(EXtensible Markup Language)
XML 它是一种标记语言,很类似 HTML,标签都是自定义的。
可扩展:内容自定义,想怎么写就怎么写
标记,就是标签。
如:
<user>标签体</user> 或 <student></student>
<人></.人> -
W3C(万维网联盟)在1988年2月发布1.0版本,2004年2月又发布1.1版本,单因为1.1版本不能向下兼容1.0版本,所以1.1没有人用。同时,在2004年2月W3C又发布了1.0版本的第三版。我们要学习的还是1.0版本。
XML 与 HTML 的主要差异
- xml标签都是自定义的,html标签是预定义。
- xml的语法严格,html语法松散。
- xml是存储数据的,html是展示数据。
xml的作用
- 存放数据
<?xml version="1.0" encoding="UTF-8"?>
<persons>
<person id="p001">
<name>张三</name>
</person>
<person id="p002">
<name>李四</name>
</person>
</persons>
类似于java代码
class Person{
String id;
String name;
}
public void test(){
HashSet<Person> persons = new HashSet<Person>();
persons.add( new Person("p001","张三") );
persons.add( new Person("p002","李四") );
}
- 配置文件–>存储数据
<?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean className="com.itheima_00_Bean.User">
<property name="username" value="jack"></property>
</bean>
</beans>
类似于java代码
class Bean{
private String username;
private String pws;
//补全set\get方法
}
import com.itheima_00_Bean.User;
public static void main(){
Class clzzz = Class.forName("com.itheima_00_Bean.User");
Object obj = clazz.newInstance();
Method method = clazz.getMethod("setUsername",String.class);
method.invoke(obj,"jack");
}
4.2 xml的组成元素(语法)
XML 文件
xml文件扩展名必须为xml
xml内容必须满足以下要求
固定的文档声明
合格的元素和属性
正确的注释
符合要求的特殊字符编写规则
文档声明
- XML文档声明格式:
<?xml version="1.0" encoding="UTF-8"?>
- 文档声明必须为<?xml开头,以?>结束;
- 文档声明必须从文档的0行0列位置开始;
- 文档声明只有2个属性:
1. versioin:指定XML文档版本。必须属性,因为我们不会选择1.1,只会选择1.0;
2. encoding:指定当前文档的编码。可选属性,默认值是utf-8;
元素(标签)
- 元素 element
<bean></bean>
- 元素是XML文档中最重要的组成部分,
- 普通元素的结构开始标签、元素体、结束标签组成。例如:大家好
- 元素体:元素体可以是元素,也可以是文本,例如:你好
- 空元素:空元素只有开始标签,而没有结束标签,但元素必须自己闭合,例如:
- 元素命名:
a. 区分大小写
b. 不能使用空格,不能使用冒号:
c. 不建议以XML、xml、Xml开头
注意:
格式化良好的XML文档,必须只有一个根元素。
属性
- 属性 attribute
<bean className=”zhangsan” id=’aa011’></bean>
-
属性是元素的一部分,它必须出现在元素的开始标签中,属性和元素使用空格分隔开,多个属性之间也是空格分割
-
属性的定义格式:属性名=属性值,其中属性值必须使用单引或双引
-
一个元素可以有0~N个属性,但一个元素中不能出现同名属性
-
属性名不能使用空格、冒号等特殊字符,且必须以字母开头
-
多个属性之间没有先后顺序
注释
XML的注释,以“ ”结束。注释内容会被XML解析器忽略!
转义字符
因为很多符号已经被XML文档结构所使用,所以在元素体或属性值中想使用这些符号就必须使用转义字符,例如:“<”、“>”、“ ’ ”、“ ” ”、“&”。
3<5 && 6>7
举例:
1<3 == 5 在xml中的写法 1<3==5
4.3 xml约束
在XML技术里,可以编写一个文档来约束一个XML文档的书写规范,这称之为XML约束。
常见的xml约束:DTD、Schema
[外链图片转存失败(img-17CuQoz9-1567134565198)(img/约束文档.bmp)]
目的:
不需要自己写出约束文档,可以大致看懂就可以了
通过约束文档,可以编写出xml文档(具有固定格式,规定的格式)。
约束文档都是别人写好的,我们拿过来用
4.3.1 DTD约束
什么是DTD
DTD(Document Type Definition),文档类型定义,用来约束XML文档。规定XML文档中元素的名称,子元素的名称及顺序,元素的属性等。
DTD重点要求
开发中,我们很少自己编写DTD约束文档,通常情况我们都是通过框架提供的DTD约束文档,编写对应的XML文档。常见框架使用DTD约束有:struts2、hibernate等。
通过提供的DTD“bean.dtd”编写XML
<?xml version="1.0" encoding="UTF-8"?>
<!--
传智播客DTD教学实例文档。
模拟spring规范,如果开发人员需要在xml使用当前DTD约束,必须包括DOCTYPE。
格式如下:
<!DOCTYPE beans SYSTEM "bean.dtd">
-->
<!ELEMENT beans (bean*,import*) >
<!ELEMENT bean (property*)>
<!ELEMENT property (#PCDATA)>
<!ELEMENT import (#PCDATA)>
<!ATTLIST bean id CDATA #REQUIRED
className CDATA #REQUIRED
>
<!ATTLIST property name CDATA #REQUIRED
value CDATA #REQUIRED
>
<!ATTLIST import resource CDATA #REQUIRED>
案例实现
完成xml内容编写
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans SYSTEM "bean.dtd">
<beans>
<bean id="" className=""></bean>
<bean id="" className="">
<property name="" value=""></property>
<property name="" value=""></property>
</bean>
<import resource=""></import>
<import resource=""></import>
</beans>
4.3.2 Schema约束
什么是Schema
Schema是新的XML文档约束;
Schema要比DTD强大很多,是DTD 替代者;
Schema本身也是XML文档,但Schema文档的扩展名为xsd,而不是xml。
Schema 功能更强大,数据类型更完善
Schema 支持名称空间(命名空间)
Schema重点要求
与DTD一样,要求可以通过schema约束文档编写xml文档。常见框架使用schema的有:Spring等
通过提供“bean-schema.xsd”编写xml文档
<?xml version="1.0" encoding="UTF-8"?>
<!--
传智播客Schema教学实例文档。
模拟spring规范,如果开发人员需要在xml使用当前Schema约束,必须包括指定命名空间。
格式如下:
<beans xmlns="http://www.itcast.cn/bean"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.itcast.cn/bean bean-schema.xsd"
>
-->
<schema xmlns="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.itcast.cn/bean"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://www.itcast.cn/bean"
elementFormDefault="qualified">
<!-- 声明根标签 -->
<element name="beans">
<complexType>
<choice minOccurs="0" maxOccurs="unbounded">
<element name="bean">
<complexType>
<sequence minOccurs="0" maxOccurs="unbounded">
<element name="property">
<complexType>
<attribute name="name" use="required"></attribute>
<attribute name="value" use="required"></attribute>
</complexType>
</element>
</sequence>
<attribute name="id" use="required"></attribute>
<attribute name="className" use="required"></attribute>
</complexType>
</element>
<element name="import">
<complexType>
<attribute name="resource" use="required"></attribute>
</complexType>
</element>
</choice>
</complexType>
</element>
</schema>
- l 案例文档中同一个“命名空间”分别使用“默认命名空间”和“显示命名空间”进行引入,所以文档中和xsd:schema作用一样。
案例实现
完成xml内容编写
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.itcast.cn/bean"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.itcast.cn/bean bean-schema.xsd"
>
<bean id="" className=""></bean>
<bean id="" className="">
<property name="" value=""/>
<property name="" value=""/>
</bean>
<import resource=""/>
<import resource=""/>
</beans>
命名空间(语法)
什么是命名空间
如果一个XML文档中使用多个Schema文件,而这些Schema文件中定义了相同名称的元素时就会出现名字冲突。这就像一个Java文件中使用了import java.util.*和import java.sql.*时,在使用Date类时,那么就不明确Date是哪个包下的Date了。
总之名称空间就是用来处理元素和属性的名称冲突问题,与Java中的包是同一用途。如果每个元素和属性都有自己的名称空间,那么就不会出现名字冲突问题,就像是每个类都有自己所在的包一样,那么类名就不会出现冲突。
约束文档和xml关系
当W3C提出Schema约束规范时,就提供“官方约束文档”。我们通过官方文档,必须“自定义schema 约束文档”,开发中“自定义文档”由框架编写者提供。我们提供“自定义文档”限定,编写出自己的xml文档。
声明命名空间
默认命名空间:<xxx xmlns=””>,使用<标签>
显式命名空间:<xxx xmlns:别名=””>,使用<别名:标签>