XML Schema 简介

ML Schema 是基于 XML 的 DTD 替代者。

XML Schema 可描述 XML 文档的结构。

XML Schema 语言也可作为 XSD（XML Schema Definition）来引用。

您应当具备的基础知识

在继续学习之前，您需要对下面的知识有基本的了解：

HTML / XHTML
XML 以及 XML 命名空间
对 DTD 的基本了解

如果您希望首先学习这些项目，请在首页访问这些教程。

什么是 XML Schema？

XML Schema 的作用是定义 XML 文档的合法构建模块，类似 DTD。

XML Schema:

定义可出现在文档中的元素
定义可出现在文档中的属性
定义哪个元素是子元素
定义子元素的次序
定义子元素的数目
定义元素是否为空，或者是否可包含文本
定义元素和属性的数据类型
定义元素和属性的默认值以及固定值

XML Schema 是 DTD 的继任者

我们认为 XML Schema 很快会在大部分网络应用程序中取代 DTD。

理由如下：

XML Schema 可针对未来的需求进行扩展
XML Schema 更完善，功能更强大
XML Schema 基于 XML 编写
XML Schema 支持数据类型
XML Schema 支持命名空间

XML Schema 是 W3C 标准

XML Schema 在 2001 年 5 月 2 日成为 W3C 标准。

本人总是爱忘记这个约束，说实话不是太难，因此想写这篇文章详细记录下，希望对有同样需要的小伙伴能够提供帮助。

Xml约束主要有两种：

dtd约束(比较简单)
schema约束（常用、复杂）

dtd约束比较简单，小伙伴们可以自行查询，我主要介绍一下schema约束。

为什么会有schema约束了，对于dtd约束，它只是对标签中的数据类型进行了一个约束，并不能对标签的数据内容进行一个约束。因此才有了scheme约束。

dtd约束文件都以.dtd结尾，scheme约束文件都以.xsd结尾。

先来看一下student.xsd文件。

<?xml version="1.0"?>
# xmlns这样写就是要给你的下面targetNamespace取别名比如xmlns:a，我这里什么都没写表示不取别名
# 这个后面如何根据Schema约束写xml可以能清晰的理解下
<xsd:schema xmlns="http://www.JHLoveCoding.cn/xml"
        # 自定义schema也需要导入一个约束，这个约束的命名空间就是URL，取了一个别名叫xsd，所以可以看 
        # 到所有下面标签都写了xsd前缀
        xmlns:xsd="http://www.w3.org/2001/XMLSchema"
        # targetNamespace自定义一个命名空间，规定该schema下所有的标签都属于这个这个命名空间下
        # elementFormDefault="qualified" 表示要引用这个命名空间必须加前缀
        targetNamespace="http://www.JHLoveCoding.cn/xml" elementFormDefault="qualified">
    # 这里type="studentsType"相当于自定义了一个类型，需要在下边声明下
    <xsd:element name="students" type="studentsType"/>
    # 这里声明了 studentsType 声明一个类型用的是xsd:complexType如果你需要经常写xml约束可以具体了解   
    # 一下，不经常写知道这么个东西就行了
    <xsd:complexType name="studentsType">
    # sequence 表示在写xml内容时，里面标签的内容必须与其在xsd这里面声明的<xsd:element/>顺序要一致
    # 我这只写了一个student，可以写多个，要是要多个，注意在写xml时，注意与这里保持一致，可以往下看
    # 你就明白了
        <xsd:sequence>
        # 这里又自定义一个studentType类型，下面会有声明，其中 minOccurs="0"表示至少出现0次，
        # maxOccurs="unbounded"这种写法表示最多无上限的
            <xsd:element name="student" type="studentType" minOccurs="0" maxOccurs="unbounded"/>
        </xsd:sequence>
    # 声明的 studentsType类型结束，下面声明过程一样的。
    </xsd:complexType>
    <xsd:complexType name="studentType">
        <xsd:sequence>
            # 这里可以看到自带的支持类型都是type="xsd:string"像这样声明的
            <xsd:element name="name" type="xsd:string"/>
            <xsd:element name="age" type="ageType" />
            <xsd:element name="sex" type="sexType" />
        </xsd:sequence>
        # 相当于给studentType添加一个自定义的属性，比如像name这样的就是属性
        <xsd:attribute name="number" type="numberType" use="required"/>
    </xsd:complexType>
    #  xsd:simpleType 定义一个简单类型, xml约束如果你只是为了能看懂，这些足够了。创作不易，喜欢的小伙伴麻烦记得点下关注+点赞+转发！用来规定和约束具有纯文本内容的元素(不含子元素即为具有纯文
    # 本内容的元素)或属性的值，不懂没关系，如果你需要经常写xml约束可以具体了解一下，不经常写知道这    
    # 么个东西就行了
    <xsd:simpleType name="sexType">
        # 对sexType内容取值做一个限制，其必须是一个字符串类型
        <xsd:restriction base="xsd:string">
            # 进一步约束，除了满足字符串之外还得满足枚举类型。
            <xsd:enumeration value="male"/>
            <xsd:enumeration value="female"/>
        </xsd:restriction>
    # 声明一个简单类型结束标志
    </xsd:simpleType>
    <xsd:simpleType name="ageType">
        # 声明ageType必须是一个整型
        <xsd:restriction base="xsd:integer">
            # 除了满足整型之外还需要满足最大值为256，最小值是0
            <xsd:minInclusive value="0"/>
            <xsd:maxInclusive value="256"/>
        </xsd:restriction>
    </xsd:simpleType>
    <xsd:simpleType name="numberType">
        <xsd:restriction base="xsd:string">
            # 除了满足是上面要求的字符串意外还要满足JH_4个数字的要求
            <xsd:pattern value="JH_\d{4}"/>
        </xsd:restriction>
    </xsd:simpleType>
</xsd:schema>

根据这个约束我们就可以根据这些约束来写一个scheme要求xml约束。

<!-- 
   1.填写xml文档的根元素 这里就是<students> </students>
   2.引入xsi前缀.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 这个是通用的做法，有很多不同的URL命名可见可供选择，xsi就是取的别名
   3.引入xsd文件命名空间.  xsi:schemaLocation="http://www.JHLoveCoding.cn/xml  student.xsd"，教你读这句话，意思就是在xsi这个命名空间下去找schemaLocation这个属性(肯定是属性，因为它写在了标签上)，对这个属性进行赋值，赋值的内容就是后面的URL
   4.为每一个xsd约束声明一个前缀,作为标识  xmlns="http://www.JHLoveCoding.cn/xml" ，首先为什么要有这个前缀的，因为比如我们下面的xml中有两个<student><student/>标签，而我们又引入了多个schema的约束，碰巧引入的这些Schema约束中都有对<student>标签做出说明，这个时候就需要引入加上命名空间了，告诉这个标签属于哪一个命名空间的约束了。由于我们这里就是一约束，故可以省略，要是多个约束为了防止冲突最好写上。
 -->
<students   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://www.JHLoveCoding.cn/xml"
         # 这里http://www.itcast.cn/xml就是xsd文件中的targetNamespace，student.xsd就是上面的约束          # 文件的名字
         xsi:schemaLocation="http://www.JHLoveCoding.cn/xml  student.xsd"
>
   <student number="JH_0001">
      <name>tom</name>
      <age>18</age>
      <sex>male</sex>
   </student >

</students>

看下边这个例子也许你会更明白一些。这里引入了三个依赖

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="

# 这里每两个空一行，只是想表示挨着的每两个就是一对的关系
  http://www.springframework.org/schema/beans # 约束文档中的命名空间
  http://www.springframework.org/schema/beans/spring-beans.xsd # 约束文档所在位置

 http://www.springframework.org/schema/context 
 http://www.springframework.org/schema/context/spring-context.xsd

http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd">

从下边的标签也可以看出来，该标签属于哪个命名空间就会有前缀作为标识。

<context:annotation-config />
    <context:component-scan base-package="cn.cisol.mvcdemo">
        <context:include-filter type="annotation"
            expression="org.springframework.stereotype.Controller" />
    </context:component-scan>
    <mvc:annotation-driven />
    <mvc:resources mapping="/resources/**" location="/resources/" />
    <bean
        class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver">
        <property name="order" value="1" />
        <property name="mediaTypes">
            <map>
                <entry key="json" value="application/json" />
                <entry key="xml" value="application/xml" />
                <entry key="htm" value="text/html" />
            </map>
        </property>
    
        <property name="defaultViews">
            <list>  
               <bean
                     class="org.springframework.web.servlet.view.json.MappingJackson2JsonView">
               </bean>
            </list>
        </property>
        <property name="ignoreAcceptHeader" value="true" />
    </bean>
    
    <bean
        class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass"
            value="org.springframework.web.servlet.view.JstlView" />
        <property name="prefix" value="/WEB-INF/jsps/" />
        <property name="suffix" value=".jsp" />
    </bean>

    <bean id="multipartResolver"
        class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="maxUploadSize" value="209715200" />
        <property name="defaultEncoding" value="UTF-8" />
        <property name="resolveLazily" value="true" />
    </bean>

</beans>

xml约束如果你只是为了能看懂，这些足够了。创作不易，喜欢的小伙伴麻烦记得点下关注+点赞+转发！

荐学习：

这可能是全网Java学习路线最完整，最详细的版本了，没有之一

Spring的出现是为了解决企业应用程序开发的复杂性它是一个分层的、JavaSE/EE一站式、轻量级开源框架。

Spring框架是一个分层架构，它包含一系列的功能要素并被分为大约20个模块。这些模块分为Core Container、Data Access/Integration、Web、AOP（Aspect Oriented Programming）、Instrumentation和测试部分。

spring的两个核心是 ioc 和 aop；
IoC（Inversion of Control 控制反转）：将对象创建的权利交给spring工厂来控制。
AOP（Aspect Oriented Programming 面向切面编程），基于动态代理的功能增强方式。

本章主要学习下ioc的内容；

第一步：创建工程导入jar 包。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>springTest</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.16</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.6.1</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>
123456789101112131415161718192021222324252627282930313233343536373839

spring 有4个核心容器的jar 包分别是Beans、Core、Context、SpEL这里我们只要引入spring-context依赖就足够了。

添加log4j.properties文件放置到src/reources下。


log4j.rootLogger=INFO,A1
log4j.logger.org.apache=INFO
log4j.appender.A1.Target=System.err
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss,SSS} [%t] [%c]-[%p] %m%n
1234567

ps：这里的日志等级可以改为debug的级别，这里为了简便设置为info的级别，有需要可以自行更改。

接下来就是写下的伪登录业务；

快速写下dao层和service层业务

package com.spring.quickTest;

public interface userDao {

    public void queryUser();
    
}

12345678

package com.spring.quickTest;

public class UserDaoImpl  implements userDao  {


    @Override
    public void queryUser() {
        System.out.println("用户登录了");
    }
}

1234567891011

package com.spring.quickTest;

public interface UserService {

  void login();


}

123456789

package com.spring.quickTest;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserServiceImpl implements UserService {

    private  userDao userDao;

    public void setUserDao(com.spring.quickTest.userDao userDao) {
        this.userDao=userDao;
    }

    @Override
    public void login() {
        System.out.println("准备登录中");
//        1.传统方法
//         userDao userDao=new UserDaoImpl();
//         userDao.queryUser();
//        2.自定义工厂
//        userDao user=(userDao) new UserdaoFactory().getBean();
//           user.queryUser();
//        3spring 工厂
//        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
//        userDao userDao=(com.spring.quickTest.userDao) context.getBean("userDao");
        
        userDao.queryUser();

    }
}

12345678910111213141516171819202122232425262728293031

传统方法下的代码过于耦合；
例如：UserDao userDao=new UserDaoImpl();
如果要更换实现类，或者实现类换一个名字，此时代码会报错，必须要修改原来的业务代码。
我们也可以通过反射的方法自定义一个bean工厂来实现代码的解耦；

package com.spring.quickTest;

public class UserdaoFactory {

    public Object getBean() {


        try {
            return Class.forName("com.spring.quickTest.UserDaoImpl").newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

       return  null ;
    }
}
1234567891011121314151617181920

我们就可以通过自定义的工厂进行实例化，然后调用dao层的方法，避免了耦合。

接下来也可以通过spring的工厂来实现解耦；
写好spring核心文件的配置文件applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
      
     <bean name="userDao" class="com.spring.quickTest.UserDaoImpl"/>
    
      <bean name="UserService" class="com.spring.quickTest.UserServiceImpl">
           <property name="userDao" ref="userDao"></property>
      </bean>
</beans>
123456789101112

我们将dao层交给spring 工厂后发现还是不够方便，就将service层也交给spring工厂来控制，将bean标签下的 property进行依赖注入这样我们只要声明下成员变量后并进行set方法赋值就可以直接引用了，不需要在创建spring工厂了。

ps：
标签说明： bean: spring工厂创建的一个对象(反射机制)
id/name:对象的名字,可以用来引用或者获取对象, 一般为类名或接口名称的首字母小写
class:要创建的对象类型的类字符串,类名全路径
注入对象
property 根据类中的setter方法进行属性注入
name:setter方法的后缀小写,比如setXxx 对应的name为xxx
ref:引用哪一个bean(对象),值为bean的id/name

import com.spring.quickTest.UserServiceImpl;
import com.spring.quickTest.UserService;
import com.spring.quickTest.UserdaoFactory;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class userTest {
    @Test
    public void test(){
//       UserService service=new UserServiceImpl();
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService service=(UserService) context.getBean("UserService");
        service.login();
    }
}

1234567891011121314151617

创建完测试类后运行成功。。。

感谢阅读，三连是最大的支持！

在线咨询

上一篇：大前端时代，如何做好 C 端业务下的 React S
下一篇：http请求中加号被替换为空格？源码背后的秘密

您的项目需求

*请认真填写需求信息，我们会在24小时内与您取得联系。

整合营销服务商

XML Schema 简介

荐学习：

您的项目需求