JavaWeb 开发之 （XML 文件操作 & 反射）
目标：
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、文档声明必须以 结束；
2、文档声明必须从文档的 0 行 0 列位置开始；
3、文档声明只有三个属性：
a. version ：指定 XML 文档版本，必须属性。
b. encoding : 指定当前文档的编码，可选属性。
元素
1、元素是 XML 文档中最重要的组成部分；
2、普通元素的结构开始标签、元素体、结束标签组成。例如 ：
3、元素体：元素体可以是元素，也可以是文本，例如： 大家好 !;
4、空元素：空元素只有开始开始标签，而没有结束标签，但是元素必须自己闭合，例如：
5、元素命名：
a. 区分大小写；
b. 不能使用空格，不能使用冒号；
c. 不建议用 XML、xml、Xml 开头；
6、格式良好的 XML 文档，必须只有一个根元素；
属性
1、属性是元素的一部分，它必须出现在元素的开始标签中；
2、属性的定义格式：属性名 = 属性值，其中属性值必须使用单引或双引；
3、一个元素可以有 0 ~ N 个属性，但一个元素中不能出现同名属性；
4、属性名不能使用空格，冒号等特殊字符，且必须以字母开头；
注释
XML 的注释与 HTML 相同，即以 "”结束，注解内容会被 XML 解析器忽略。
DTD 约束
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 支持命名空间
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 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
已经声明的构造方法：Constructor
实例化对象实例
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
myServlet1
com.ma.web.servlet1.MyServlet1
myServlet1
/myServlet1
myServlet2
com.ma.web.servlet1.MyServlet2
myServlet2
/myServlet2
测试类
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();
}
}
}
运行结果
