XML&反射

最新推荐文章于 2021-12-30 10:25:52 发布

weixin_30607659

最新推荐文章于 2021-12-30 10:25:52 发布

阅读量267

点赞数 1

文章标签： web.xml java 移动开发

原文链接：http://www.cnblogs.com/zhaojiankai/p/7846207.html

版权

本节内容：

XML
DTD约束
Schema约束
dom4j解析
反射

为了实现访问不同路径（/hello）执行不同的资源（HelloMyServlet），我们需要使用XML进行配置；为了限定XML内容，我们需要使用xml约束（DTD或schema）；为了获得xml的内容，我们需要使用dom4j进行解析。更多XML的介绍参见w3cschool。

一、XML

1. 什么是XML

XML全称是Extensible Markup Language，意思是可扩展的标记语言。XML语法上和HTML比较相似，但HTML中的元素是固定的，而XML标签是可以由用户自定义的。

W3C在1998年2月发布了1.0版本，2004年2月发布了1.1版本，但因为1.1版本不能向下兼容1.0版本，所以1.1没有人用。同时在2004年2月W3C又发布了1.0版本的第三版。我们现如今用的仍然是1.0版本。

2. XML常见的用法

（1）配置文件

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5">
  <servlet>
    <servlet-name>HelloMyServlet</servlet-name>
    <servlet-class>com.itheima.HelloMyServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>HelloMyServlet</servlet-name>
    <url-pattern>/hello</url-pattern>
  </servlet-mapping>
</web-app>

（2）存放数据

【注意】：现在用于传输的一般是JSON，而不使用XML。

<?xml version="1.0" encoding="UTF-8"?>
<persons>
  <person id="p001">
    <name>张三</name>
  </person>
  <person id="p002">
    <name>王五</name>
  </person>
</persons>

3. XML语法

（1）XML文档声明

<?xml version="1.0" encoding="UTF-8"?>

文档声明必须为 <?xml 开头，以 ?> 结束；
文档声明必须从文档的0行0列位置开始；
文档声明只有两个属性：
- version：指定XML文档版本。必须属性，因为我们不会选择1.1，只会选择1.0
- encoding：指定当前文档的编码。可选属性，默认是utf-8

（2）元素 element

<servlet>

元素是XML文档中最重要的组成部门
普通元素的结构由开始标签、元素体、结束标签组成。例如：<hello>大家好</hello>
元素体：元素体可以是元素，也可以是文本。例如：<b><a>大家好</a></b>
空元素：空元素只有开始标签，没有结束标签，但元素必须自己闭合。例如：<c/>
元素命名：
- 区分大小写
- 不能使用空格
- 不建议以XML、xml、Xml开头
格式化良好的文档，必须只有一个根元素

（3）属性

<web-app version="2.5">

属性是元素的一部分，它必须出现在元素的开始标签中
属性的定义格式：属性名=属性值，其中属性值必须使用单引号或双引号
一个元素可以有0~N个属性，但一个元素中不能出现同名属性
属性名不能使用空格、冒号等特殊字符，且必须以字母开头

（4）注释

XML的注释和HTML相同，即以“”结束。注释内容会被XML解析器忽略！

（5）转义字符

XML中的转义字符与HTML一样。

因为很多符号已经被XML文档结构所使用，所以在元素体或属性值中想使用这些符号就必须使用转义字符，例如：“<”、“>”、“'”、“"”、“&”。

字符	字符引用（十进制代码）	字符引用（十六进制代码）	预定义实体引用
<	<	<	<
>	>	>	>
"	"	"	"
'	'	'	'
&	&	&	&

（6）CDATA区

<![CDATA[
    任意内容
]]>

当大量的转义字符出现在xml文档中时，会使xml文档的可读性大幅度降低。这时如果使用CDATA段就会好一些。

在CDATA段中出现的“<”、“>”、“'”、“"”、“&”，都无需使用转义字符。这可以提高xml文档的可读性。

在CDATA段中不能包含“]]>”，即CDATA段的结束定界符。

<?xml version="1.0" ?>
<hello version="1" id="1" >
    <a11111>
        
    </a11111>
    <!-- 大家好！ -->
    <a/>
    <c>&lt;AAAA</c>
    <b>
        <![CDATA[
            if(a>b&&b<c){
            if……
            }
        ]]>
    </b>
    
</hello>

示例

二、DTD约束

常见的xml约束：DTD、Schema。

<?xml version="1.0" ?>
<!-- 约束 -->
<hello version="1" id="1" >
    <a11111>
        
    </a11111>
    <!-- 大家好！ -->
    <a/>
    <c>&lt;AAAA</c>
    <b>
        <![CDATA[
            if(a>b&&b<c){
            if……
            }
        ]]>
    </b>
</hello>

约束在XML文章中的位置

1. 什么是DTD

DTD（Document Type Definition），文档类型定义，用来约束XML文档。规定XML文档中元素的名称，子元素的名称及顺序，元素的属性等。

2. DTD重点要求

开发中，我们很少自己编写DTD约束文档，通常情况我们都是通过框架提供的DTD约束文档，编写对应的XML文档。常见框架使用的约束有：struts2、hibernate等。

比如通过提供的DTD“web-app_2_3.dtd”编写XML，该文件内容如下(.dtd文档可以用nodepad++等软件打开)：

<?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>

web-app_2_3.dtd

3. 案例实现

步骤1：创建web.xml文档，并将“web-app_2_3.dtd”拷贝到相同目录下。

步骤2：从DTD文档开始处，拷贝需要的“文档说明”

步骤3：完成xml文档编写

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE web-app SYSTEM "web-app_2_3.dtd">
<web-app version="1.0">
    <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>

XML文档示例

4. DTD语法

（1）文档声明

a.内部DTD，在XML文档内部嵌入DTD，只对当前XML有效。

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<!DOCTYPE web-app [
    ... //具体的语法
]>
<web-app>
</web-app>

b.外部DTD——本地DTD，DTD文档在本地系统上，公司内部自己项目使用

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<!DOCTYPE web-app SYSTEM "web-app_2_3.dtd">
<web-app>
</web-app>

c.外部DTD——公共DTD，DTD文档在网络上，一般都有框架提供

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<!DOCTYPE web-app  PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
</web-app>

（2）元素声明

定义元素语法：<!ELEMENT 元素名元素描述>

　　元素名：自定义

　　元素描述包含：符号和数据类型

　　　　常见符号：? * + () | ,

　　　　常见类型：#PCDATA 表示内容是文本，不能是子标签

符号	符号类型	描述	示例
?	问号	表示该对象可以出现，但只能出现一次	(菜鸟?)
*	星号	表示该对象允许出现任意多次，也可以是零次	(爱好*)
+	加号	表示该对象最少出现一次，可以出现多次	(成员+)
()	括号	用来给元素分组	(古龙\|金庸\|梁羽生),(张三\|李四),王五
\|	竖条	表明在列出的对象中选择一个	(男人\|女人)
,	逗号	表明对象必须按指定的顺序出现	(西瓜,苹果,香蕉)

【示例】：

<!ELEMENT web-app (servlet*, servlet-mapping*, welcome-file-list?) >
    web-app 包含3个标签，且必须按顺序出现
        servlet 子标签个数任意
        servlet-mapping 子标签个数任意
        welcome-file-list 子标签最多只能出现一次

<!ELEMENT servlet (servlet-name*, description?, (servlet-class|jsp-file)) >
    servlet 有3个子标签，且必须按顺序出现
    servlet-name，必须有，且只能出现一次
    description，可选一次
    servlet-class 和 jsp-file 二选一，且只能出现一次

<!ELEMENT servlet-name (#PCDATA) >
    servlet-name 的标签体必须是文本

<!ELEMENT welcome-file-list (welcome-file+) >
    welcome-file-list 至少有一个子标签 welcome-file

（3）属性声明

<!ATTLIST 元素名

　　属性名 属性类型 约束
　　属性名 属性类型 约束
　　...
>
元素名：属性必须是给元素添加，所有必须先确定元素名
属性名：自定义
属性类型：ID、CDATA、枚举 ...
    ID：ID类型的属性用来标识元素的唯一性
    CDATA：文本类型
    枚举：(e1 | e2 | ...)多选一
约束：
    #REQUIRED：说明属性是必须的；required
    #IMPLIED：说明属性是可选的；implied

属性的语法(attribute)

<!ATTLIST web-app version CDATA #IMPLIED>
    给 web-app 元素添加version属性，属性值必须是文本，且可选。
    <web-app version="2.3"> 和 <web-app> 都符合结束。

示例

对于DTD文档，我们要能够根据别人给的DTD文档写出XML文件。

三、Schema约束

1. 什么是Schema

Schema是新的XML文档约束
Schema要比DTD强大很多，是DTD替代者
Schema本身也是XML文档，但Schema文档的扩展名为xsd，而不是xml
Schema功能更强大，数据类型更完善
Schema支持名称空间：为了区分同样的属性

2. Schema重点要求

与DTD一样，要求可以通过schema约束文档编写xml文档。常见框架使用schema的有：Spring等。

比如通过“web-app_2_5.xsd”编写xml文档，该文档内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<!-- 
    模拟servlet2.5规范，如果开发人员需要在xml使用当前Schema约束，必须包括指定命名空间。
    格式如下：
    <web-app xmlns="http://www.example.org/web-app_2_5" 
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://www.example.org/web-app_2_5 web-app_2_5.xsd"
            version="2.5">
-->
<xsd:schema xmlns="http://www.w3.org/2001/XMLSchema" 
    targetNamespace="http://www.example.org/web-app_2_5"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:tns="http://www.example.org/web-app_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>

web-app_2_5.xsd

该文档中同一个“命名空间”分别使用“默认命名空间”和“显式命名空间”进行引入，所以文档中<schema>和<xsd:schema>作用一样。

3. 案例实现

步骤1：创建web.xml，并将“web-app_2_5.xsd”拷贝到同级目录

步骤2：从xsd文档中拷贝需要的“命名空间”

步骤3：完成xml内容编写

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://www.example.org/web-app_2_5" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.example.org/web-app_2_5 web-app_2_5.xsd"
    version="2.5">

    <servlet>
        <servlet-name>helloServlet</servlet-name>
        <servlet-class>xxxxxxxxxx</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>helloServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
</web-app>

web.xml

4. 命名空间（语法）

（1）什么是命名空间

如果一个XML文档中使用多个Schema文件，而这些Schema文件中定义了相同名称的元素时就出现名字冲突。这就像一个java文件中使用了import java.util.*和import java.sql.*时，在使用Date类时，那么就不明确Date是哪个包下的Date了。

名称空间就是用来处理元素和属性的名称冲突问题，与java中的包是同一用途。如果每个元素和属性都有自己的名称空间，那么就不会出现名字冲突问题，就像是每个类都有自己所在的包一样，那么类名就不会出现冲突。

（2）约束文档和XML关系

当w3c提出Schema约束规范时，就提供“官方约束文档”。我们通过官方文档，必须“自定义schema约束文档”，开发中“自定义文档”由框架编写者提供。我们提供“自定义文档”限定，编写出自己的xml文档。

（3）声明命名空间

默认命名空间：<xxx xmlns="">，使用<标签>
显式命名空间：<xxx xmlns:别名="">，使用<别名:标签>

示例：web-app_2_5.xsd

<xsd:schema xmlns="http://www.w3.org/2001/XMLSchema" ...>
    表示自定义schema约束文档引用官方文档作为显示命名空间。如果要使用官方提供的元素或属性，必须使用xsd前缀（自定义，此处表示官方文档，所以使用xsd）
    <xsd:schema>标签就有官方文档提供，默认命名空间直接使用

示例：web.xml

<web-app xmlns="http://www.example.org/web-app_2_5" ...>
    表示xml文档引用“自定义约束文档”作为默认命名空间
    因为使用默认命名空间，<web-app>直接使用

（4）其他介绍

自定义约束：web-app_2_5.xsd

<xsd:schema targetNamespace=http://www.example.org/web-app_2_5
    表示当前自定义约束文档进行起名，提供给xml文档使用。

xml文档：web.xml

<web-app 
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.example.org/web-app_2_5 web-app_2_5.xsd"
    
    xmlns:xsi=""  固定写法
        表示是一个schema实例文档，就是被schemaw文档约束的xml文档。
    xsi:schemaLocation="名称 路径  名称 路径  名称 路径  ..."
        表示用于确定当前xml文档使用到的schema文档的位置。“名称 路径”是成对出现，与xmlns引用命名空间对应。

一般schema约束都是别人提供好了，我们拿过来按照要求写出XML文档即可。

四、dom4j解析

（1）XML解析概述

当将数据存储在XML后，我们就希望通过程序获得XML的内容。如果我们使用Java基础所学习的IO知识是可以完成的，不过你需要非常繁琐的操作才可以完成，且开发中会遇到不同问题（只读、读写）。人们为不同问题提供不同的解析方式，并提交对应的解析器，方便开发人员操作XML。

（2）解析方式和解析器

开发中比较常见的解析方式有三种，如下：

DOM：要求解析器把整个XML文档载入内存，并解析成一个Document对象。
- 优点：元素和元素之间保留结构关系，故可以进行增删改查操作。
- 缺点：如果XML文档过大，可能出现内存溢出

SAX：是一种速度更快，更有效的方法。它逐行扫描文档，一边扫描一边解析。并以事件驱动的方式进行具体解析，每执行一行，都将触发对应的事件
- 优点：处理速度快，可以处理大文件
- 缺点：只能读，逐行后将释放资源。而且不能往回读。
PULL：Android内置的XML解析方式，类似SAX

解析器：就是根据不同的解析方式提供的具体实现。有的解析器操作过于繁琐，为了方便开发人员，有提供易于操作的解析开发包。

常见的解析开发包：

JAXP：sun公司提供支持DOM和SAX开发包
JDom：dom4j兄弟
jsoup：一种处理HTML特定解析开发包
dom4j：比较常用的解析开发包，hibernate底层采用

（3）DOM解析原理及结构模型

XML DOM和HTML DOM类似，XML DOM将整个XML文档加载到内存，生成一个DOM树，并获得一个Document对象，通过Document对象就可以对DOM进行操作。

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5">
    <servlet>
        <servlet-name>helloServlet</servlet-name>
        <servlet-class>cn.itcast.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>helloServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
</web-app>

DOM的核心概念是节点，在XML文档中的元素、属性、文本等，在DOM中都是节点。

（4）API使用

如果需要使用dom4j，必须导入jar包。

dom4j必须使用核心类SaxReader加载xml文档获得Document，通过Document对象获得文档的根元素，然后就可以操作了。

常用API如下：

SaxReader对象
- read(...) 加载执行xml文档

Document对象
- getRootElement() 获得根元素
Element对象
- elements(...) 获得指定名称的所有子元素。可以不指定名称
- element(...) 获得指定名称第一个元素。可以不指定名称
- getName() 获得当前元素的元素名
- attributeValue(...) 获得指定属性名的属性值
- elementText(...) 获得指定名称子元素的文本值
- getText() 获得当前元素的文本内容

【示例】：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://www.example.org/web-app_2_5" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.example.org/web-app_2_5 web-app_2_5.xsd"
    version="2.5">

    <servlet>
        <servlet-name>helloServlet</servlet-name>
        <servlet-class>xxxxxxxxxx</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>helloServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
</web-app>

web.xml

public class TestDom4j {
    @Test
    public void testReadWebXML() {
        try {
            // 1.获取解析器
            SAXReader saxReader = new SAXReader();
            // 2.获得document文档对象
            Document doc = saxReader.read("src/cn/itheima/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) {
                //6.判断元素名称为servlet的元素
                if ("servlet".equals(element.getName())) {
                    //7.获取servlet-name元素
                    Element servletName = element.element("servlet-name");
                    //8.获取servlet-class元素
                    Element servletClass = element.element("servlet-class");
                    System.out.println(servletName.getText());
                    System.out.println(servletClass.getText());
                }
            }

        } catch (DocumentException e) {
            e.printStackTrace();
        }
    }

}

TestDom4j.java

五、反射

1. 什么是反射

Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性
使用反射，可以在运行时对类Class、构造方法Constructor、普通方法Method、字段Field进行操作

通俗点讲：反射就是动态获取指定类以及类中的内容(成员)，并运行其内容。

应用程序已经运行，代码已经加载到内存了，无法在其中进行new对象的建立，就无法使用对象。这时可以根据配置文件的类全名去找对应的字节码文件，并加载进内存，并创建该类对象实例。这就需要使用反射技术完成。

2. Class对象

Class对象，是对class文件（字节码文件）的描述对象

获得Class对象：

已知类的完整路径名（字符串）：Class.forName(...)
已知类型：String.class，确定参数列表
已知对象：obj.getClass()

常用方法：

使用默认构造方法创建实例：newInstance()

3. Constructor对象

Constructor对象是构造方法的描述对象。

获得构造方法：

公共的构造方法：Constructor<T> getConstructor(Class<?>... parameterTypes)，可变参数用于确定形式参数列表
私有构造方法：Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)，获得私有的构造

实例化对象实例：

newInstance(Object... initargs)，可变参数用于确定实际参数列表

4. Method对象

Method对象是普通方法的描述对象

获得方法：

获得公共方法：Method getMethod(String name, Class<?>... parameterTypes) 通过方法 name 获得方法，可变参数为方法的形式参数列表
获得私有方法：Method getDeclaredMethod(String name, Class<?>... parameterTypes)

执行指定方法：

Object invoke(Object obj, Object... args) 执行指定对象obj，指定方法，可变参数为方法的实际参数列表

5. Field对象

Field对象是字段的描述对象

获得方法：

所有字段：Field getField(String name) 通过字段名称
私有字段：Field getDeclaredField(String name)

操作：

获得内容：Object get(Object obj)
设置内容：void set(Object obj, Object value) 确定实例对象

6. 详解获取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); --之前在读取jdbc的driver使用的就是这个
相对方便的多，不需要直接使用具体的类，只要知道该类的名字即可。
而名字完成可以作为参数进行传递（比如把类全名写在properties配置文件中），这样就可以提高扩展性。
所以为了动态获取一个类，第三种方式最为常用。

Class clazz = Class.forName("com.wisedu.bean.Person");//必须类全名

第三种方式最常用，框架就是使用这种方式的。

【示例1】：

以前：

先加载cn.itcast.bean.Person类进内存。
将该类封装成Class对象。
根据Class对象，用new操作符创建cn.itcast.bean.Person对象。
调用构造函数对该对象进行初始化。cn.itcast.bean.Person p = new cn.itcast.bean.Person();

通过方式三：(此外还可以使用构造，构造可以指定参数---如String.class)

String className = "cn.itcast.bean.Person";

根据名称获取其对应的字节码文件对象

1. 通过forName()根据指定的类名称去查找对应的字节码文件，并加载进内存。
2. 并将该字节码文件封装成了Class对象。
3. 直接通过newIntstance方法，完成该对象的创建。
4. newInstance方法调用就是该类中的空参数构造函数完成对象的初始化。

Class clazz = Class.forName(className);

通过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);//对哪个对象调用方法，是参数组
好处：大大的提高了程序的扩展性。

【示例2】：

package cn.itheima.web.servlet;

public interface IMyServlet {

    public void init();

    public void service();

    public void destory();
}

接口IMyServlet.java

package cn.itheima.web.servlet;

public class MyServletImpl implements IMyServlet {

    @Override
    public void init() {
        System.out.println("啊，俺来也……");
    }

    @Override
    public void service() {
        System.out.println("我可以为你服务……");
    }

    @Override
    public void destory() {
        System.out.println("啊，俺去也……");
    }

}

实现类MyServletImpl.java

package cn.itheima.web.servlet;

import org.junit.Test;

public class TestMyServlet {

    @Test
    public void testMyServlet(){
        MyServletImpl my = new MyServletImpl();
        my.init();
        my.service();
        my.destory();
    }
    
    @Test
    public void testMyServlet1(){
        try {
            String className = "cn.itheima.web.servlet.MyServletImpl"; //或者让进配置文件中，防止硬编码
            Class clazz = Class.forName(className);
            MyServletImpl my = (MyServletImpl) clazz.newInstance();
            my.init();
            my.service();
            my.destory();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

反射测试TestMyServlet.java

【示例3】：通过读取配置文件的方式来使用反射完成对实例对象方法调用

package cn.itheima.web.servlet1;

public interface IMyServlet {

    public void init();

    public void service();

    public void destory();
}

接口IMyServlet.java

package cn.itheima.web.servlet1;

public class MyServlet1 implements IMyServlet{

    @Override
    public void init() {
        System.out.println("MyServlet1诞生了……");
    }

    @Override
    public void service() {
        System.out.println("MyServlet1开始服务了……");
    }

    @Override
    public void destory() {
        System.out.println("MyServlet1销毁了……");
    }

}

实现类MyServlet1.java

package cn.itheima.web.servlet1;

public class MyServlet2 implements IMyServlet{

    @Override
    public void init() {
        System.out.println("MyServlet2诞生了……");
    }

    @Override
    public void service() {
        System.out.println("MyServlet2开始服务了……");
    }

    @Override
    public void destory() {
        System.out.println("MyServlet2销毁了……");
    }

}

实现类MyServlet2.java

package cn.itheima.web.servlet1;

import org.dom4j.Document;
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/cn/itheima/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();
            //System.out.println(servletClass);
            //6.通过类全名获取字节码文件
            Class clazz = Class.forName(servletClass);
            //7.创建实例对象
            MyServlet1 my = (MyServlet1) clazz.newInstance();
            //8.调用实例对象里面的方法
            my.init();
            my.service();
            my.destory();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

反射调用对象方法TestMyServlet.java

上面的代码已经解析了xml，不过获得的内容都是固定的，我们希望如果用户访问的路径是/myServlet1，将执行cn.itheima.web.servlet1.MyServlet1程序，如果访问/myServlet2，将执行cn.itheima.web.servlet1.MyServlet2程序。

在执行测试程序前(@Before)，解析xml文件，将解析的结果放在Map中，Map中数据的格式为：请求路径=实现类。比如："/myServlet1"="cn.itheima.web.servlet1.MyServlet1"

然后模拟浏览器请求路径，通过url从map中获得class，并使用反射执行实现类。

package cn.itheima.web.servlet1;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.junit.Before;
import org.junit.Test;

public class TestMyServlet2 {
    //8.创建一个map集合
    private HashMap<String, String> data = new HashMap<String,String>();
    
    @Before
    public void testReadWEBXml(){
        try {
            //1.创建解析器对象
            SAXReader saxReader = new SAXReader();
            //2.使用解析器加载web.xml文件得到document对象
            Document document = saxReader.read("src/cn/itheima/web/servlet1/web.xml");
            //3.获取根元素节点
            Element rootElement = document.getRootElement();
            //4.获取子节点(servlet和servlet-mapping)
            List<Element> childElements = rootElement.elements();
            //5.遍历
            for (Element element : childElements) {
                //6.判断元素的名称为servlet的元素节点
                if("servlet".equals(element.getName())){
                    //7.分别获取servlet元素节点的servlet-name和servlet-class的值
                    String servletName = element.element("servlet-name").getText();
                    String servletClass = element.element("servlet-class").getText();
                    /*System.out.println(servletName);
                    System.out.println(servletClass);*/
                    data.put(servletName, servletClass);
                }
                //9.判断元素的名称为servlet-mapping的元素节点
                if("servlet-mapping".equals(element.getName())){
                    //10.分别获取servlet元素节点的servlet-name和servlet-class的值
                    String servletName = element.element("servlet-name").getText();
                    String urlPattern = element.element("url-pattern").getText();
                    //11.将servletName作为key来获取servletClass的值
                    String servletClass = data.get(servletName);
                    //12.将url-pattern作为key,servletClass作为value存到map中去
                    data.put(urlPattern, servletClass);
                    //13.移除servletName
                    data.remove(servletName);
                }
            }
            //System.out.println(data);
            
        } catch (DocumentException e) {
            e.printStackTrace();
        }
    }
    
    @Test
    public void testMyServlet(){
        try {
            //1.模拟在浏览器输入一个url
            String url1 = "/myServlet2";
            //2.将urlPattern作为key来获取servletClass
            String className = data.get(url1);
            //3.通过servletClass获取字节码文件
            Class clazz = Class.forName(className);
            //4.通过字节码文件创建实例对象
            Object obj = clazz.newInstance();
            //5.通过字节码文件获取方法(两个参数：第一个是方法名称；第二个参数是方法的参数)
            Method method = clazz.getMethod("service", null);
            //6.调用invoke方法执行实例对象里面的方法(前面写的方法init)【两个参数：第一个是调用方法的实例对象，第二个是方法的实参】
            method.invoke(obj, null);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

TestMyServlet2.java

转载于:https://www.cnblogs.com/zhaojiankai/p/7846207.html

weixin_30607659

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
XML&反射

本节内容：XMLDTD约束Schema约束dom4j解析反射为了实现访问不同路径（/hello）执行不同的资源（HelloMyServlet），我们需要使用XML进行配置；为了限定XML内容，我们需要使用xml约束（DTD或schema）；为了获得xml的内容，我们需要使用dom4j进行解析。更多XML的介绍参见w3cschool。一、XML1. 什么是X...
复制链接

扫一扫