ID属性的声明必须被置于最后
<xs:attribute name="orderid" type="xs:string" use="required"/>

ComplexContent的用法：

<?xml version="1.0" encoding="UTF-8"?>
<xs:element name="employee" type="fullpersoninfo"/>

<xs:complexType name="personinfo">
  <xs:sequence>
    <xs:element name="firstname" type="xs:string"/>
    <xs:element name="lastname" type="xs:string"/>
  </xs:sequence>
</xs:complexType>

<xs:complexType name="fullpersoninfo">
  <xs:complexContent>
    <xs:extension base="personinfo">
      <xs:sequence>
        <xs:element name="address" type="xs:string"/>
        <xs:element name="city" type="xs:string"/>
        <xs:element name="country" type="xs:string"/>
      </xs:sequence>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

1.
准确说是一种Java XML数据绑定技术。
http://www.iteye.com/topic/582459:
<bind-xml name="borndate" node="attribute"/> ，name规定了这个值在xml中的显示名，而node规定了该值的xml存储方式，这里是用attribute形式进行存储，即写到了结点的属性里。   
2.Castor介绍----比较详细易懂的BLOG：
http://www.open-open.com/lib/view/open1326514404093.html

mapping.xml配置如下：  

首先，看看这个xml文档的根元素是mapping，在mapping中可以配置class。也就是我们要转换的JavaObject的配置描述了。  

class元素的name属性就是配置的JavaObject的classpath路径了。  

关于class元素的auto-complate属性，如果这个属性的值为ture。那么编组后的xml，castor会自动给没有在mapping配置文件进行配置的属性自动编组（转换）到xml中。如果为false，那么在mapping配置文件中出现的属性将在编组后不现在在编组后的xml中。  

map-to就是当前class编组后的xml文档的节点元素名称。  

field就是描述JavaObject中的属性，name是Java对象的属性名称，type是类型。关于配置的type类型也有规定，你可以参考：http://www.castor.org/xml-mapping.html的field配置讲解。  

而field还有其他的属性配置，如get-method应该是getter方法、set-method应该是setter的方法、has-mehtod 应该是hashCode方法，有时候我们不一定要提高getter、setter方法，我们需要用自己的方法名称来代替setter、getter。如果当前field配置的是集合类型，那么你需要给field元素配置collection属性。  

bind-xml就是绑定（编组）成xml后的xml内容的描述，name就是编组后xml的节点元素名称，node有2个值，分别是 attribute、element。attribute是属性，它会在节点元素的属性中显示，例如：<account id=”2”></account>  

而element则是单独的一个元素，例如：<account><id>2</id></account>  

就这个样子的。  

mapping.xml还可以有其他标签，如：  

<include href="other_mapping_file.xml"/>  

导入外部xml文件，可以分多个配置。  




 

AnyURI 数据类型（AnyURI Data Type）

anyURI 数据类型用于规定 URI。

下面是一个关于某个 scheme 中 anyURI 声明的例子：

<xs:attribute name="src" type="xs:anyURI"/>

文档中的元素看上去应该类似这样：

<pic src="http://www.w3school.com.cn/images/smiley.gif" />

XML Schema 是基于 XML 的 DTD 替代者。
XML Schema 描述 XML 文档的结构。
XML Schema 语言也称作 XML Schema 定义（XML Schema Definition，XSD）。
在此教程中，你将学习如何在应用程序中读取和创建 XML Schema 语言，XML Schema 为何比 DTD 更加强大，以及如何在您的应用程序中使用 XML Schema。

XML中的Schema元素详解：

http://www.w3school.com.cn/schema/schema_schema.asp

XML Schema：
<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.w3school.com.cn"
xmlns="http://www.w3school.com.cn"
elementFormDefault="qualified">

<xs:element name="note">
    <xs:complexType>
      <xs:sequence>
<xs:element name="to" type="xs:string"/>
<xs:element name="from" type="xs:string"/>
<xs:element name="heading" type="xs:string"/>
<xs:element name="body" type="xs:string"/>
      </xs:sequence>
    </xs:complexType>
</xs:element>

</xs:schema>

 

 

定义简易元素

定义简易元素的语法：

<xs:element name="xxx" type="yyy"/>

xs:string

xs:decimal

xs:integer

xs:boolean

xs:date

xs:time

 定义属性

<xs:attribute name="lang" type="xs:string" fixed="EN"/>


限定（restriction）用于为 XML 元素或者属性定义可接受的值。对 XML 元素的限定被称为 facet。

使用 extension 或 restriction 元素来扩展或限制元素的基本简易类型。

 

WSDL是Web Service的描述语言，是一种接口定义语言，用于描述Web Service的接口信息等。WSDL元素^[1]基于XML语法描述了与服务进行交互的基本元素：
　　Type（消息类型）：数据类型定义的容器，它使用某种类型系统（如XSD）。
　　Message（消息）：通信数据的抽象类型化定义，它由一个或者多个part组成。
　　Part：消息参数

      Operation(操作)：对服务所支持的操作进行抽象描述，WSDL定义了四种操作：
1.单向（one-way）：端点接受信息；2.请求-响应（request-response）：端点接受消息，然后发送相关消息；3.要求-响应（solicit-response）：端点发送消息，然后接受相关消息；4.通知（notification
）：端点发送消息。
　　Port Type （端口类型）：特定端口类型的具体协议和数据格式规范。
　　Binding：特定端口类型的具体协议和数据格式规范
　　Port ：定义为绑定和网络地址组合的单个端点。
　　Service：相关端口的集合，包括其关联的接口、操作、消息等。

HQL(Hibernate Query Language):是面向对象的查询语句,它的语法和SQL语句有些相像,在运行时才得以解析.HQL并不像SQL那样是数据操作语言,它用来取得对象,而不是进行update,delete和insert操作. HQL 是一门对大小写不敏感的的语言,所以SeLect与SELECT和sELeCT是相同的. ---------------- 现在有四张表:student,team,course,student_course. student 表中有五个字段,分别是:id,name,cardId,age,team_id;    team      表中有两个字段,id,teamname; course 表中有id,name; student_course 表中有stu_id,course_id;      保存多对多的关系表 ---------------- Student 是一个对象,student 是数据库中的一个表. 查询所有的Student对象时,最简单的HQL语句是: from Student,也可以写成 select s from Student (as)s. 注:这的as可以省略   1:简单的查询遍历对象: 遍历Student Query query=session.createQuery("form Student");       //注: 如果Student对象不是唯一的,那么需要写上包名,如: from test.Student      test为包名. List list=query.list(); for(int i=0;i<list.size();i++) { Student stu=(Student)list.get(i); System.out.println(stu.getName()); } 注意: 如果执行HQL语句"from Student,Course",并不时单单返回两个对象,而是返回两个对象的笛卡尔积,这类似SQL语句中字段的全外连接.实际的应用中,"from Student,Course"这种语句几乎是不回出现的. 2:属性查询:       ----单个属性查询: Query query=session.createQuery("select s.name form Student s"); List list=query.list(); for(int i=0;i<list.size();i++) { String name=(String)list.get(i); System.out.println(name); }       ----多个属性查询: Query query=session.createQuery("select s.name,s.age form Student s"); List list=query.list(); for(int i=0;i<list.size();i++) { Object obj[]=(Object[])list.get(i);       //取得list中的第i个对象 System.out.println(obj[0]+"的年龄为: "+obj[1]); } 3:实例化查询: 实例化查询结果可以说是对属性查询的一重改进.在使用属性查询时由于使用对象数组,操作和理解不太方便,如果将以个Object[]中的成员封装成一个对象就方便多了. Query query=session.createQuery("select new Student(s.name,s.age) form Student s"); List list=query.list(); for(int i=0;i<list.size();i++) { Student stu=(Student)list.get(i); System.out.println(stu.getName()); } 注:运行这个程序的时候,需要一个new Student(s.name,s.age)构造函数.在Student.java中编写这个构造函数. public Student(String name,int age) { this.name=name; this.age=age; }   4:查询链接: 与SQL查询一样,HQL也支持连接查询,如内连接,外连接和交叉连接.支持的链接类型是从ANSI SQL中借鉴来的.       1: inner jion      (内连接) 2: left outer join (左外连接) 3: right outer join(右外连接) 4: full join(全连接--不常用) inner jion 可以简写为join. 正常情况下必须要建关联。 select a.id, b.id from A a, B b where a.id = b.id; 上面每条记录返回的是一个Object[]对象。 你也可以把结果重新封装一下。 String hql = "select a.id, b.id from A a, B b where a.id = b.id"; List result = getHibernateTemplate().find(hql); if (result.size() > 0) { for (int i = 0; i < result.size(); i++){ Object[] obj = (Object[]) result.get(i); //这里就可以重新封装数据 } } 5:统计函数查询: 1: count()       统计记录的条数 2: min() 求最小值 3: max() 求最大值 4: sum() 求和 4: avg() 求平均值 //取得Student的数量 Query query=session.createQuery("select count(*) from Student")   //avg()取得Student平均年龄 Query query=session.createQuery("select avg(s.age) from Student as s")   //upper()方法将字符串转为大写 Query query=session.createQuery("select upper(s.name) from Student as s")   //去除重复行distinct Query query=session.createQuery("select distinct s.age from Student as s")     6:子查询: all 表示所有记录 any 便是所有记录中的任意一条 somy 与any用法一样 in 等价于any exists 表示子查询至少要返回一条数据. all: from Team t where 22<all(select s.age from Student s) from Team t where all(select s.age from      t.student s)>22   7:修改 update() Student stu=(Student)session.get(Student.class,"id");      //根据id 得到stu对象 stu.setName("123"); session.update(stu); 8:删除:   delete() Student stu=(Student)session.get(Student.class,"id");      //根据id 得到stu对象 session.delete(stu);

     摘要: 看这个链接作了解：http://zhaohe162.blog.163.com/blog/static/3821679720110251181721/一、HQL查询的from子句 from是最简单的语句，也是最基本的HQL语句。from关键字后紧跟持久化类的类名。 例如： from Person  表明从Person持久化类中选出全部的实例 推荐为Person持久化类的每个实例起别...  阅读全文

Hibernate的核心接口之一

　　SessionFactory接口:SessionFactroy接口负责初始化Hibernate。它充当数据存储源的代理，并负责创建Session对象。这里用到了工厂模式。需要注意的是SessionFactory并不是轻量级的，因为一般情况下，一个项目通常只需要一个SessionFactory就够，当需要操作多个数据库时，可以为每个数据库指定一个SessionFactory.

示例如下： 　　/** 　　*@param str 　　*@param int 　　*更新String类型的字段 　　*/ 　　public int updateDm_bm(String str){ 　　int resu=0; 　　//获取会话工厂 　　SessionFactory sf=this.getSessionFactory(); 　　//获取SessionFactory的会话 　　Session session=(Session)this.getSessionFactory().getCurrentSession(); 　　sf.openSession(); 　　//开始事务 　　Transaction t=session.beginTransaction(); 　　Query query =session.createQuery(str); 　　//提交事务 　　resu=query.executeUpdate(); 　　// Query.executeUpdate()方法返回的整型值表明了受此操作影响 　　return resu; 　　} 　　此方法如果传入一条数据修改语句。就可以直接执行返回成功与否的结果。 　　而此处的SessionFactory一旦声明，就不必去估计数据库连接的问题，很方便。
二、getHibernateTemplate 
      http://www.cnblogs.com/JemBai/archive/2011/01/17/1937413.html Software entities should be open for extension,but closed for modification.
意思是说,一个软件实体应当对扩展开放,对修改关闭.也就是说,我们在设计一个模块的时候,应当使这个模块可以在不被修改的前提下被扩展,换句话说就是,应当可以在不必修改源代码的情况下改变这个模块的行为.
满足OCP的设计给系统带来两个无可比拟的优越性. 　　1.通过扩展已有的软件系统,可以提供新的行为,以满足对软件的新需求,使变化中的软件系统有一定的适应性和灵活性. 　　2.已有的软件模块,特别是最重要的抽象层模块不能再修改,这就使变化中的软件系统有一定的稳定性和延续性. 例如： 　　编程模式中的工厂模式的“工厂方法”支持OCP原则

首先你要明白在java里面任何class都要装载在虚拟机上才能运行。这句话就是装载类用的(和new 不一样，要分清楚)。 

至于什么时候用，你可以考虑一下这个问题，给你一个字符串变量，它代表一个类的包名和类名，你怎么实例化它？只有你提到的这个方法了，不过要再加一点。 
A a = (A)Class.forName("pacage.A").newInstance(); 
这和你 
A a = new A()； 
是一样的效果。 

关于补充的问题 
答案是肯定的，jvm会执行静态代码段，你要记住一个概念，静态代码是和class绑定的，class装载成功就表示执行了你的静态代码了。而且以后不会再走这段静态代码了。

Class.forName(xxx.xx.xx) 返回的是一个类 
Class.forName(xxx.xx.xx);的作用是要求JVM查找并加载指定的类，也就是说JVM会执行该类的静态代码段

动态加载和创建Class 对象，比如想根据用户输入的字符串来创建对象 
String str = 用户输入的字符串 
Class t = Class.forName(str); 
t.newInstance();

 在初始化一个类，生成一个实例的时候，newInstance()方法和new关键字除了一个是方法，一个是关键字外，最主要有什么区别？它们的区别在于创建对象的方式不一样，前者是使用类加载机制，后者是创建一个新类。那么为什么会有两种创建对象方式？这主要考虑到软件的可伸缩、可扩展和可重用等软件设计思想。 

Java中工厂模式经常使用newInstance()方法来创建对象，因此从为什么要使用工厂模式上可以找到具体答案。 例如： 
class c = Class.forName(“Example”); 
factory = (ExampleInterface)c.newInstance(); 

其中ExampleInterface是Example的接口，可以写成如下形式： 
String className = "Example"; 
class c = Class.forName(className); 
factory = (ExampleInterface)c.newInstance(); 

进一步可以写成如下形式： 
String className = readfromXMlConfig;//从xml 配置文件中获得字符串 
class c = Class.forName(className); 
factory = (ExampleInterface)c.newInstance(); 

上面代码已经不存在Example的类名称，它的优点是，无论Example类怎么变化，上述代码不变，甚至可以更换Example的兄弟类Example2 , Example3 , Example4……，只要他们继承ExampleInterface就可以。 

从JVM的角度看，我们使用关键字new创建一个类的时候，这个类可以没有被加载。但是使用newInstance()方法的时候，就必须保证：1、这个类已经加载；2、这个类已经连接了。而完成上面两个步骤的正是Class的静态方法forName()所完成的，这个静态方法调用了启动类加载器，即加载 java API的那个加载器。 

现在可以看出，newInstance()实际上是把new这个方式分解为两步，即首先调用Class加载方法加载某个类，然后实例化。 这样分步的好处是显而易见的。我们可以在调用class的静态加载方法forName时获得更好的灵活性，提供给了一种降耦的手段。 

最后用最简单的描述来区分new关键字和newInstance()方法的区别： 
newInstance: 弱类型。低效率。只能调用无参构造。 
new: 强类型。相对高效。能调用任何public构造。

下面内容转自
http://blog.csdn.net/iceman1952/archive/2007/03/07/1523025.aspx
介绍的是 forName() 和 ClassLoader 的 loadClass 方法。
现在终于知道了为什么 forName()是会执行 static 语句，因为默认情况它总是初始化这个被装载的类。

关于forName()方法
这个方法总是返回要加载的类的Class类的实例
1、forName(String className)单参数时, initialize=true
    a.总是使用当前类装载器(也就是装载执行forName()请求的类  的类装载器)
    b.总是初始化这个被装载的类(当然也包括：装载、连接、初始化)
2、forName(String className, boolean initialize, ClassLoader loader)
    a.loader指定装载参数类所用的类装载器，如果null则用bootstrp装载器。
    b.initialize=true时，肯定连接，而且初始化了；
    c.false时，绝对不会初始化，但是可能被连接了，但是这里有个例外，如果在调用这个forName()前，已经被初始化了，那么返回的类型也肯定是被初始化的(当然，这里也暗含着：被同一个loader所装载的，而且这个类被初始化了)

关于用户自定义的类装载器的loadClass()方法
1、loadClass(String name)单参数时, resolve=false
    a.如果这个类已经被这个类装载器所装载，那么，返回这个已经被装载的类型的Class的实例，否则，就用这个自定义的类装载器来装载这个class，这时不知道是否被连接。绝对不会被初始化
    b.这时唯一可以保证的是，这个类被装载了。但是不知道这个类是不是被连接和初始化了
2、loadClass(String name, boolean resolve)
    a.resolve=true时，则保证已经装载，而且已经连接了。resolve=falses时，则仅仅是去装载这个类，不关心是否连接了，所以此时可能被连接了，也可能没有被连接




终于明白为什么加载数据库驱动只用Class.forName（）了！！困扰了我2个小时！！希望我写的这个东西对各位有所帮助。

  
   在Java开发特别是数据库开发中，经常会用到Class.forName( )这个方法。通过查询Java Documentation我们会发现使用Class.forName( )静态方法的目的是为了动态加载类。在加载完成后，一般还要调用Class下的newInstance( )静态方法来实例化对象以便操作。因此，单单使用Class.forName( )是动态加载类是没有用的，其最终目的是为了实例化对象。
   这里有必要提一下就是Class下的newInstance()和new有什么区别？，首先，newInstance( )是一个方法，而new是一个关键字，其次，Class下的newInstance()的使用有局限，因为它生成对象只能调用无参的构造函数，而使用 new关键字生成对象没有这个限制。
   好，到此为止，我们总结如下：
   Class.forName("")返回的是类
   Class.forName("").newInstance()返回的是object
   有数据库开发经验朋友会发现，为什么在我们加载数据库驱动包的时候有的却没有调用newInstance( )方法呢？即有的jdbc连接数据库的写法里是Class.forName(xxx.xx.xx);而有一 些：Class.forName(xxx.xx.xx).newInstance()，为什么会有这两种写法呢？
   刚才提到，Class.forName("");的作用是要求JVM查找并加载指定的类，如果在类中有静态初始化器的话，JVM必然会执行该类的静态代码 段。而在JDBC规范中明确要求这个Driver类必须向DriverManager注册自己，即任何一个JDBC Driver的 Driver类的代码都必须类似如下：
  public class MyJDBCDriver implements Driver {
   static {
     DriverManager.registerDriver(new MyJDBCDriver());
  }
  }
既然在静态初始化器的中已经进行了注册，所以我们在使用JDBC时只需要Class.forName(XXX.XXX);就可以了。