1、学习目标
使用反射模拟servlet执行。
能够编写xml存听任意内容
经过DTD约束编写指定格式的XML
经过Schema约束编写指定格式的XML
可使用D0M4解析XML
会使用反射对类、方法、构造进行相应操做
2、相关技术
为了灵活实现不一样路径（/hello）执行不一样的资源（HelloMyServlet）咱们须要使用XML进行配置；为了限定XML内容，咱们须要使用XML约束（DTD或schema）；为了得到xml的内容，咱们须要使用dom4j
进行解析。
什么是XML？
XML全称是Extensible Markup Language，意思是能够扩展的标记语言。XML标签是能够由用户自定义的。（用于配置文件）
XML的做用？
一、配置文件（
主要）
二、存放数据（传输数据）
XML语法？
一、XML文档声明
<?xml version="1.0" encoding="UTF-8">
a、文档声明必须为<?xml 开头，以？>结束
b、文档声明必须从文档的0行0列位置开始
c、文档只有三个属性 version encoding
二、元素element
三、属性
四、注释
五、转义字符
六、CDATA区
DTD约束？
DTD（Document Type Definition），文档类型定义，用来约束XML文档。
DTD重点要求：不多本身编写DTD约束文档，都是经过框架提供的DTD约束文档编写对象的XML文档。常见框架使用DTD约束有：struts二、hibernate等。
DTD文档声明
一、内部DTD，在CML文档内部嵌入DTD，只对当前XML有限
二、外部DTD-本地DTD，DTD文档在本地系统上，公司内部自动项目使用 关键字：
SYSTEM
三、外部DTD-公共DTD，DTD文档在网络上，通常都由框架提供 关键字：
PUBLIC
元素声明？
定义元素语法：<!ELEMENT 元素名 元素描述>
元素名：自定义
元素描述：符号和数据类型
常见符号：
？ ：该对象能够出现，但只能出现一次
*：任意次或零次
+ ：最少出现一次
（） ：给元素分组
| ：选择一个
，：顺序出现
常见类型：
#PCDATA表示内容是文本，不能是子标签
约束文档：
<?xml version="1.0" encoding="UTF-8"?>
<!--
DTD教学实例文档。
模拟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>
注：经过框架提供的DTD文档，本身可以写出xml文件。
Schema约束 ？
Schema约束比DTD强大不少，是DTD的替代者。主要用于spring
重点要求：
经过schema约束文档编写xml文件。
<?xml version="1.0" encoding="UTF-8"?>
<!--
Schema教学实例文档。
模拟servlet2.5规范，若是开发人员须要在xml使用当前Schema约束，必须包括指定命名空间。
格式以下：
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>
dom4j 解析？
当数据存储在XML中，咱们就但愿经过程序得到XML的内容。人们为不一样问题提供不一样的解析方式，并提交对应的解析器，方便开发人员操做XML。
开发中比较常见的解析方式有三种：
一、DOM：java主要用的。
DOM将文档一次性加载到内存造成树形结构，进行解析。
优势：方便对数形结构进行操做，能够进行增、删、改的操做。
缺点：若是文档特别大，加载到内存中，容易致使内存溢出。
二、SAX：事件驱动方式，边读边解析。
优势：不会致使内存溢出。
缺点：不能增删改操做。
三、PULL
常见的解析开发包：
JAXP：sun公司提供支持DOM和SAX开发包
JDom：dom4j兄弟
jsoup：一种处理HTML特定解析开发包
dom4j：比较经常使用的解析开发包，hibernate底层采用
API使用：
若是须要使用dom4j，必须导入jar包。
dom4j必须使用核心类SaxReader加载xml文档得到Document，经过Document对象得到文档的根元素，而后就能够操做了。
常见API以下：
1.SaxReader对象
read（...）：加载执行xml文档
2.Document对象
getRootElement（）：得到根元素
3.Element对象
a、elements（） 得到全部子元素
b、element（）得到指定名称第一个子元素
c、getName（）得到当前元素的元素名
d、attributeValue（）得到指定属性名的属性值
e、elementText（）得到指定名称子元素的文本值
f、getText（）得到当前元素的文本内容
实现步骤(掌握)：
一、导入jar包 ：dom4j-1.6.1.jar
二、编写web.xml
三、解析web.xml
web.xml
<?xml version="1.0" encoding="UTF-8"?>
version="2.5">
<servlet>
<servlet-name>helloServlet</servlet-name>
<servlet-class>ct.FirstServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>helloServlet</servlet-name>
<url-pattern>/test</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
</web-app>
package com.scalpel.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/scalpel/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 elementName = element.element("servlet-name");
Element elementClass = element.element("servlet-class");
System.out.println(elementName.getText());
System.out.println(elementClass.getText());
}
}
} catch (DocumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
3、反射
为了模拟服务器端程序，且能够同时存在多个相似程序。故提供接口，接口中有3个方法，咱们人为约定三个方法的调用顺序：
public interface MyServlet
{
public void destory();
}
实现接口方法的类，而后Test类调用。
@Test
public void testMyServlet()
{
MyServlet my = new MyServlet();
my.init();
my.service();
my.destory();
}
测试程序咱们能够直接new MyServlet();这种编码方式咱们成为硬编码，即代码写死了。为了后期程序的可扩展，开发中一般使用实现类的全限定类名。经过反射加载字符串指定的类，并经过反射建立实例。
什么是反射？
JACA反射机制是在运行状态中，对应任意一个类，都可以知道这个类的全部属性和方法，对应任意一个对象，都可以调用它的任意一个方法和属性。
反射
一、什么是反射技术？
动态获取指定类以及类中的内容(成员)，并运行其内容。
应用程序已经运行，没法在其中进行new对象的创建，就没法使用对象。这时能够根据配置文件的类全名（包名+类名）去找对应的字节码文件，并加载进内存，并建立该类对象实例。这就须要使用反射技术完成
二、获取class对象的三种方式
获取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);//对哪一个对象调用方法，是参数组
好处：大大的提升了程序的扩展性。
@Test
public void testMyServletClass()
{
try {
String className = "com.scalpel.web.servlet.MyServlet";
Class clazz = Class.forName(className);
MyServlet my = (MyServlet) clazz.newInstance();
my.init();
my.service();
my.destory();
} catch (Exception e) {
e.printStackTrace();
}
}
4、读取配置文件，根据配置文件调用类的方法实现
一、添加dom4j-1.6.1.jar包 （使用dom4j解析配置文件）
二、添加xsd文档 （web-app_2_5.xsd，改文档为Schema约束文档）
三、编写IMyServlet.java接口类
四、实现接口类MyServlet.java
五、编写web.xml文件
六、编写测试类 TestMyServletAll.java （根据解析web.xml文件来调用MyServlet类里面的方法）
代码：
IMyServlet.java
package com.scalpel.web.servletAll;
public interface IMyServlet {
public void init();
public void service();
public void destory();
}
MyServlet.java
package com.scalpel.web.servletAll;
public class MyServlet implements IMyServlet {
@Override
public void init() {
System.out.println("MyServlet star");
}
@Override
public void service() {
System.out.println("MyServlet service");
}
@Override
public void destory() {
System.out.println("MyServlet end");
}
}
web.xml
<?xml version="1.0" encoding="UTF-8"?>
version="2.5">
<servlet>
<servlet-name>MyServlet</servlet-name>
<servlet-class>com.scalpel.web.servletAll.MyServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>MyServlet</servlet-name>
<url-pattern>/myServlet</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>MyServletTwo</servlet-name>
<servlet-class>com.scalpel.web.servletAll.MyServletTwo</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>MyServletTwo</servlet-name>
<url-pattern>/myServletTwo</url-pattern>
</servlet-mapping>
</web-app>
TestMyServletAll.java
package com.scalpel.web.servletAll;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.junit.Test;
public class TestMyServletAll {
@Test
public void testMyServlet()
{
try {
//1.建立解析器对象
SAXReader saxReader = new SAXReader();
//2.使用解析器加载web.xml文档获得document对象
Document document = saxReader.read("src/com/scalpel/web/servletAll/web.xml");
//3.获取根元素节点
Element rootElement = document.getRootElement();
//4.根据元素名称获取子元素节点(获取第一个servlet)
Element servletElement = rootElement.element("servlet");
//5.根据元素名称获取servlet-class的文本节点
String servletClass = servletElement.element("servlet-class").getText();
//System.out.println(servletClass);
//6.经过类全名获取字节码文件
Class clazz = Class.forName(servletClass);
//7.建立实例对象
MyServlet my = (MyServlet) clazz.newInstance();
//8.调用实例对象里面的方法
my.init();
my.service();
my.destory();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
备注：很简单的代码。可是思想很重要，在公司中，每一个人负责的模块不同，不必定可以看到别人负责的源代码，当你须要调用其余同事写的接口的时候，就须要查看web.xml（配置文件）文档，而后解析，调用其余同事的接口。最后完成本身负责模块的功能。