目标:
1、可以编写 XML 存放任意内容
2、通过 DTD 约束编写指定格式的 XML
3、通过 Schema 约束 编写指定的 XML
4、可以使用 DOM4J解析 XML
5、会使用反射对类、方法、构造进行相应操作
什么是 XML ?
XML 全称 Extensible Markup Language ,意思是可扩展的标记语言。XML 语法上和 HTML 比较相似,但是 HTML 中的元素是固定的,而 XML 的标签是用户可以自定义的。
XML 语法:
XML 文档声明
<?
xml
version
=
"1.0"
encoding
=
"UTF-8"
?>
1、文档声明必须以 <?xml 开头,以 ?>结束;
2、文档声明必须从文档的 0 行 0 列位置开始;
3、文档声明只有三个属性:
a. version :指定 XML 文档版本,必须属性。
b. encoding : 指定当前文档的编码,可选属性。
元素
<servlet>
1、元素是 XML 文档中最重要的组成部分;
2、普通元素的结构开始标签、元素体、结束标签组成。例如 :<hello>大家好 !</hello>;
3、元素体:元素体可以是元素,也可以是文本,例如:<a><b> 大家好 !</b></a>;
4、空元素:空元素只有开始开始标签,而没有结束标签,但是元素必须自己闭合,例如:<c/>;
5、元素命名:
a. 区分大小写;
b. 不能使用空格,不能使用冒号;
c. 不建议用 XML、xml、Xml 开头;
6、格式良好的 XML 文档,必须只有一个根元素;
属性
<web-app verssion = "2.5">
1、属性是元素的一部分,它必须出现在元素的开始标签中;
2、属性的定义格式:属性名 = 属性值,其中属性值必须使用单引或双引;
3、一个元素可以有 0 ~ N 个属性,但一个元素中不能出现同名属性;
4、属性名不能使用空格,冒号等特殊字符,且必须以字母开头;
注释
XML 的注释与 HTML 相同,即以 "<!--" 开始,以“-->”结束,注解内容会被 XML 解析器忽略。
DTD 约束
<
?xml version="1.0" encoding="UTF-8"?
>
<
!--
实例文档。
模拟servlet2.3规范,如果开发人员需要在
xml
使用当前DTD约束,必须包括DOCTYPE。
格式如下:
<!DOCTYPE web-
app
SYSTEM "web-app_2_3.
dtd
">
-->
<!ELEMENT
web-app
(
servlet
*,
servlet-mapping
*
,
welcome-file-list
?
)
>
<!ELEMENT
servlet
(
servlet-name
,
description
?,
(
servlet-class
|
jsp-file
))
>
<!ELEMENT
servlet-mapping
(
servlet-name
,
url-pattern
+
)
>
<!ELEMENT
servlet-name
(#PCDATA)
>
<!ELEMENT
servlet-class
(#PCDATA)
>
<!ELEMENT
url-pattern
(#PCDATA)
>
<!ELEMENT
description
(#PCDATA)
>
<!ELEMENT
jsp-file
(#PCDATA)
>
<!ELEMENT
welcome-file-list
(
welcome-file
+
)
>
<!ELEMENT
welcome-file
(#PCDATA)
>
<!ATTLIST
web-app
version
CDATA
#IMPLIED
>
<?
xml
version=
"1.0"
encoding=
"UTF-8"
?>
<!
DOCTYPE
web-app
SYSTEM
"web-app_2_3.dtd"
>
<
web-app
>
<
servlet
>
<
servlet-name
></
servlet-name
>
<
servlet-class
></
servlet-class
>
</
servlet
>
<
servlet-mapping
>
<
servlet-name
></
servlet-name
>
<
url-pattern
></
url-pattern
>
</
servlet-mapping
>
<
welcome-file-list
>
<
welcome-file
></
welcome-file
>
</
welcome-file-list
>
</
web-app
>
Schema 约束
XML Schema 是基于 XML 的 DTD 替代者。
XML Schema 描述 XML 文档的结构。
XML Schema 语言也称作 XML Schema 定义(XML Schema Definition,XSD)。
XML Schema 是 DTD 的继任者
我们认为 XML Schema 很快会在大部分网络应用程序中取代 DTD。
理由如下:
- XML Schema 可针对未来的需求进行扩展
- XML Schema 更完善,功能更强大
- XML Schema 基于 XML 编写
- XML Schema 支持数据类型
- XML Schema 支持命名空间
<?
xml
version=
"1.0"
encoding=
"UTF-8"
?>
<!--
实例文档。
模拟servlet2.5规范,如果开发人员需要在
xml
使用当前Schema约束,必须包括指定命名空间。
格式如下:
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
version="2.5">
-->
elementFormDefault=
"qualified"
>
<
xsd:element
name=
"web-app"
>
<
xsd:complexType
>
<
xsd:choice
minOccurs=
"0"
maxOccurs=
"unbounded"
>
<
xsd:element
name=
"servlet"
>
<
xsd:complexType
>
<
xsd:sequence
>
<
xsd:element
name=
"servlet-name"
></
xsd:element
>
<
xsd:element
name=
"servlet-class"
></
xsd:element
>
</
xsd:sequence
>
</
xsd:complexType
>
</
xsd:element
>
<
xsd:element
name=
"servlet-mapping"
>
<
xsd:complexType
>
<
xsd:sequence
>
<
xsd:element
name=
"servlet-name"
></
xsd:element
>
<
xsd:element
name=
"url-pattern"
maxOccurs=
"unbounded"
></
xsd:element
>
</
xsd:sequence
>
</
xsd:complexType
>
</
xsd:element
>
<
xsd:element
name=
"welcome-file-list"
>
<
xsd:complexType
>
<
xsd:sequence
>
<
xsd:element
name=
"welcome-file"
maxOccurs=
"unbounded"
></
xsd:element
>
</
xsd:sequence
>
</
xsd:complexType
>
</
xsd:element
>
</
xsd:choice
>
<
xsd:attribute
name=
"version"
type=
"double"
use=
"optional"
></
xsd:attribute
>
</
xsd:complexType
>
</
xsd:element
>
</
xsd:schema
>
<?
xml
version=
"1.0"
encoding=
"UTF-8"
?>
version=
"2.5"
>
<
servlet
>
<
servlet-name
></
servlet-name
>
<
servlet-class
></
servlet-class
>
</
servlet
>
<
servlet-mapping
>
<
servlet-name
></
servlet-name
>
<
url-pattern
></
url-pattern
>
</
servlet-mapping
>
<
welcome-file-list
>
<
welcome-file
></
welcome-file
>
</
welcome-file-list
>
</
web-app
>
dom4j 解析
当将数据存储在 XML 后,我们就希望通过程序获得 XML 的内容,通过解析器可以完成这种操作。
解析方式和解析器
开发中常见的解析方式有三种,如下:
1、DOM :要求解析器将整个 XML 文档装载到内存,并解析成一个 Document 对象。
a. 优点 :元素与元素之间保留结构关系,故可以进行增删改查操作。
b. 缺点 :XML 文档过大,可能会出现内存溢出现象。
2、SAX : 是一种速度更快,更有效的方式。它逐行扫描文档,一边扫描一边解析。并以事件驱动的方式进行具体解析每执行一行都将触发对应的事件。
a. 优点 :处理速度快,可以处理大文件。
b. 缺点 :只能读,逐行后将释放资源。
3、PULL : Android 内置的 XML 解析方式,类似 SAX。
常见的解析开发包:
JAXP : sun 公司提供支持 DOM 和 SAX 开发包。
Jdom : dom4j 的兄弟。
jsoup : 一种处理 HTML 特定解析开发包。
dom4j : 比较常用的解析开发包,hibernate 底层采用。
解析 XML 文件
package com.ma.xml.dom4j;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.junit.Test;
public
class TestDom4j {
@Test
public
void
testReadWebXML(){
try {
//1、获取解析器
SAXReader saxReader =
new SAXReader();
//2、获得 document 文档对象
Document doc = saxReader.read(
"src/com/ma/xml/schema/web.xml");
//3、获取根元素
Element rootElement = doc.getRootElement();
//获取根元素名称
//System.out.println(rootElement.getName());
//获取根元素的属性值
//System.out.println(rootElement.attributeValue("version"));
//4、获取根元素下面的子元素
List<Element> childElements = rootElement.elements();
//5、遍历子元素
for (Element element : childElements) {
if(
"servlet".equals(element.getName())){
Element servletName = element.element(
"servlet-name");
Element servletClass = element.element(
"servlet-class");
System.
out.println(servletName.getText());
System.
out.println(servletClass.getText());
}
}
}
catch (DocumentException e) {
e.printStackTrace();
}
}
}
结果
现在我们先来看段代码
接口
package
com.ma.web.servlet;
public
interface
MyServlet {
public
void
init
();
public
void
service();
public
void
destory();
}
实现类
package com.ma.web.servlet;
public
class MyServletImpl
implements MyServlet {
public
void init() {
System.
out.println(
"初始化 !");
}
public
void service() {
System.
out.println(
"执行 !");
}
public
void destory() {
System.
out.println(
"销毁 !");
}
}
测试类
package com.ma.web.servlet;
import org.junit.Test;
public
class TestMyServlet {
@Test
public
void testMyServlet(){
MyServletImpl my =
new MyServletImpl();
my.init();
my.service();
my.destory();
}
}
结果
反射执行
测试程序时我们直接 new MyServletImpl(); 这种编码方式我们称之为硬编码,即代码写死了,为了后期的程序扩展性,开发中通常使用实现类的全限定(com.ma.web.servlet.MyServletImpl),通过反射加载字符串指定的类,并通过反射创建实例。
反射
什么是反射
JAVA 反射机制是在运行状态中,对于任何一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性。
使用反射,可以在运行时对类 Class、构造方法 Constructor、普通方法 Method、字段 Filed 进行操作。
Class 对象
Class 对象,是对 class 文件(字节码文件)的描述对象。
获得 Class 对象
已知类的完整路径名(字符串):Class.forName(...);
已知类型 : String.class 确定参数列表;
已知对象 :obj.getClass();
常用方法:使用默认构造方法创建实例:newInstance();
Constructor 对象
Constructor 对象,是构造方法的描述对象。
获得构造方法
公共的构造方法:Constructor<T> getConstructor(Class<?>...parameter Types),可变参数用于确定实际参数列表 ;
已经声明的构造方法:Constructor<T> getDeclaredConstructor(Class<?>...parameterTypes),获得私有的构造;
实例化对象实例
newInstance(Object...initargs),可变参数用于确定实际参数列表
Method 对象
Method 对象,是普通方法的描述对象。
获得方法:
获得公共方法:Method getMethod(String name,Class<?>...parameterTypes),通过方法 name 获得方法,可变参数为方法的形式参数表;
获得声明方法:Method getDeclaredMethod(String name, Class<?>...parameterTypes) 方法操作;
执行指定方法:Object invoke(Object obj, Object ... args) 执行指定对象 obj 指定方法,可变参数为方法的实际参数列表;
Filed 对象
Filed 对象,是字段的描述对象
获得方法:
所有字段:Filed getFiled(String name),通过字段名称;
声明字段:Filed getDeclaredFiled(String name)
操作:
获取内容:Object get(Object obj)
设置内容:void set(Object obj, Object value),确定实例对象;
获取
Class对象的方式一:
通过对象具备的getClass方法(源于Object类的方法)。有点不方便,
需要用到该类,并创建该类的对象,再调用getClass方法完成。
Person
p = new
Person();
//
创建
Peron
对象
Class clazz =
p.getClass();
//
通过
object
继承来的方法
(getClass)
获取
Person
对应的字节码文件
对象
获取
Class对象的方式二:
每一个类型都具备一个class静态属性,通过该属性即可获取该类的字节码文件对象。比第一种简单了一些,仅用一个静态属性就搞定了。但是,还是有一点不方便,还必须要
使用到该类。
Class clazz =
Person.class;
获取
Class对象方式三:
* 去找找Class类中是否有提供获取的方法呢?
* 找到了,static Class forName(className);
* 相对方便的多,不需要直接使用具体的类,只要知道该类的名字即可。
* 而名字完成可以作为参数进行传递 ,这样就可以提高扩展性。
* 所以为了动态获取一个类,第三种方式
最
为常用。
Class clazz = Class.forName("
cn.itcast.bean.Person");//必须类全名
创建一个实例
创建
Person
对象的方式
以前:
1,先加载cn.itcast.bean.Person类进内存。
2,将该类封装成Class对象。
3,根据Class对象,用new操作符创建cn.itcast.bean.Person对象。
4,调用构造函数对该对象进行初始化。
cn.itcast.bean.Person
p = new
cn.itcast.bean.Person
();
通过方式三:
(
此外还可以使用构造,构造可以指定参数
---
如
String.class
)
String className = "cn.itcast.bean.Person";
//1,根据名称获取其对应的字节码文件对象
1,通过forName()根据指定的类名称去查找对应的字节码文件,并加载进内存。
2,并将该字节码文件封装成了Class对象。
3,直接通过newIntstance方法,完成该对象的创建。
4,newInstance方法调用就是该类中的空参数构造函数完成对象的初始化。
Class clazz = Class.forName(className);
//2,通过Class的方法完成该指定类的对象创建。
Object object = clazz.newInstance();
//该方法用的
清单
1
,
获取字节码文件中的字段。
Class
clazz = Class.
forName
(
"cn.itcast.bean.Person"
);
//获取该类中的指定字段。比如age
Field field = clazz.
getDeclaredField("age")
;
//clazz.getField("age");
//为了对该字段进行操作,必须要先有指定类的对象。
Object obj = clazz.newInstance();
//
对私有访问,必须取消对其的访问控制检查
,使用
AccessibleObject父类中的setAccessible的方法
field.setAccessible(
true
);
//暴力访问。建议大家尽量不要访问私有
field.set(obj, 789);
//获取该字段的值。
Object o = field.get(obj);
System.
out
.println(o);
备注:
getDeclaredField
:
获取所有
属性,包括私有。
getField:
获取公开属性,包括从父类继承过来的,不包括非公开方法。
清单
2
,
获取字节码文件中的
方法
。
//根据名称获取其对应的字节码文件
对象
Class clazz = Class.
forName
(
"cn.itcast.bean.Person"
);
//调用字节码文件对象的方法getMethod获取class对象所表示的类的公共成员方法(指定方法),参数为方法名和当前方法的参数,无需创建对象,它是静态方法
Method method = clazz.getMethod(
"staticShow"
,
null
);
//调用class对象所表示的类的公共成员方法,需要指定对象和方法中的参数列表
method.invoke(
null
,
null
);
………………………………………………………………………………………………………
Class clazz = Class.
forName
(
"cn.itcast.bean.Person"
);
//获取指定方法。
Method method = clazz.getMethod(
"publicShow"
,
null
);
//获取指定的类对象。
Object obj = clazz.newInstance();
method.invoke(obj,
null
);
//
对哪个对象调用方法,是参数组
好处:
大大的提高了程序的扩展性。
模拟框架中使用的 XML 方式解析文件获得类的路径并通过反射调用方法
接口类
package com.ma.web.servlet1;
public
interface MyServlet {
public
void init();
public
void service();
public
void destory();
}
实现类 1
package
com.ma.web.servlet1;
public
class
MyServlet1
implements
MyServlet {
@Override
public
void
init() {
System.
out
.println(
"初始化 !"
);
}
@Override
public
void
service() {
System.
out
.println(
"执行中 !"
);
}
@Override
public
void
destory() {
System.
out
.println(
"销毁 !"
);
}
}
实现类 2
package com.ma.web.servlet1;
public
class MyServlet2
implements MyServlet {
@Override
public
void init() {
System.
out.println(
"初始化 !");
}
@Override
public
void service() {
System.
out.println(
"执行中 !");
}
@Override
public
void destory() {
System.
out.println(
"销毁 !");
}
}
web.xml
<?
xml
version
=
"1.0"
encoding
=
"UTF-8"
?>
version
=
"2.5"
>
<
servlet
>
<
servlet-name
>
myServlet1
</
servlet-name
>
<
servlet-class
>
com.ma.web.servlet1.MyServlet1
</
servlet-class
>
</
servlet
>
<
servlet-mapping
>
<
servlet-name
>
myServlet1
</
servlet-name
>
<
url-pattern
>
/myServlet1
</
url-pattern
>
</
servlet-mapping
>
<
servlet
>
<
servlet-name
>
myServlet2
</
servlet-name
>
<
servlet-class
>
com.ma.web.servlet1.MyServlet2
</
servlet-class
>
</
servlet
>
<
servlet-mapping
>
<
servlet-name
>
myServlet2
</
servlet-name
>
<
url-pattern
>
/myServlet2
</
url-pattern
>
</
servlet-mapping
>
<
welcome-file-list
>
<
welcome-file
></
welcome-file
>
</
welcome-file-list
>
</
web-app
>
测试类
package com.ma.web.servlet1;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.junit.Test;
public
class TestMyServlet {
@Test
public
void
testMyServlet(){
try {
//1、创建解析器对象
SAXReader saxReader =
new SAXReader();
//2、使用解析器对象加载 web.xml 文件,得到 document 对象
Document document =saxReader.read(
"src/com/ma/web/servlet1/web.xml");
//3、获取根元素节点
Element rootElement = document.getRootElement();
//4、根据元素名称获取子元素节点
Element servletElement = rootElement.element(
"servlet");
//5、根据元素名称获取
servlet
-class 的文本
String servletClass = servletElement.element(
"servlet-class").getText();
try {
//6、通过类全名获取字节码文件
Class clazz = Class.forName(servletClass);
//7、创建实例对象
try {
MyServlet1 myServlet1 = (MyServlet1) clazz.newInstance();
//8、调用实例对象的方法
myServlet1.init();
myServlet1.service();
myServlet1.destory();
}
catch (InstantiationException e) {
e.printStackTrace();
}
catch (IllegalAccessException e) {
e.printStackTrace();
}
}
catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
catch (DocumentException e) {
e.printStackTrace();
}
}
}
运行结果