Collections (Maps, Lists, Sets)

在框架中会经常遇到处理集合 Collections (Maps, Lists, and Sets), 下面列出几个使用select 标签处理集合的列子.  OGNL documentation 也包括许多列子.

Syntax for list: {e1,e2,e3}. 这个语法创建了一个包含字符串“name1”，“name2”和“name3”的List，并且选择“name2”作为默认值。

<s:select label="label" name="name" list="{'name1','name2','name3'}" value="%{'name2'}" />

Syntax for map: #{key1:value1,key2:value2}. 这个语法创建了一个Map键值对集合，“foo”对应“foovalue”，“bar”对应“barvalue”：

<s:select label="label" name="name" list="#{'foo':'foovalue', 'bar':'barvalue'}" />

判断一个元素是否存在于一个集合中，使用in 或 not in 操作。
<s:if test="'foo' in {'foo','bar'}">
   muhahaha
</s:if>
<s:else>
   boo
</s:else>

<s:if test="'foo' not in {'foo','bar'}">
   muhahaha
</s:if>
<s:else>
   boo
</s:else>

选择集合的一个子集（也叫投影），可以使用通配符：

例如，获得人的亲属集合中为男性的一个子集

person.relatives.{? #this.gender == 'male'}

Lambda Expressions
OGNL supports basic lamba expression syntax enabling you to write simple functions.
(Dedicated to all you math majors who didn't think you would ever see this one again.)
Fibonacci: if n==0 return 0; elseif n==1 return 1; else return fib(n-2)+fib(n-1);

fib(0) = 0

fib(1) = 1

fib(11) = 89


    
    

        

            

            
How the expression works

            
The lambda expression is everything inside the square brackets. The #this variable holds the argument to the expression, which in the following example is the number 11 (the code after the square-bracketed lamba expression, #fib(11)).
            
        
    




<s:property value="#fib =:[#this==0 ? 0 : #this==1 ? 1 : #fib(#this-2)+#fib(#this-1)], #fib(11)" />

 1 /**
 2  * @(#)IBaseDAO.java 2009-9-14 下午03:05:59
 3  * Copyright 2009 Bobby_Guo, Inc. All rights reserved
 4  */
 5 package cn.commonframework.util;
 6 
 7 import java.io.Serializable;
 8 import java.util.List;
 9 
10 import org.hibernate.criterion.Criterion;
11 
12 /**
13  * @description:公用DAO接口，包含基本的增、删、改、查操作.
14  * @author  :Bobby_Guo <br>
15  * @version :1.0    <br>
16  * @date    :2009-9-14 下午03:12:53 <br>
17  * @param <T>
18  */
19 public interface IBaseDAO<T> {
20     /**
21      * 保存一个实体对象
22      * @param t
23      */
24     public void save(T t);
25     /**
26      * 更新一个实体对象
27      * @param t
28      */
29     public void update(T t);
30     /**
31      * 批量更新
32      * @param hql
33      * @param o
34      * @return
35      */
36     public int batchUpdate(String hql,Object o);
37     /**
38      * 删除一个实体对象
39      * @param t
40      */
41     public void delete(T t);
42     /**
43      * 根据主键查找实体对象
44      * @param id
45      * @return
46      */
47     public T findById(Serializable id);
48     /**
49      * 查找所有实体对象
50      * @return
51      */
52     public List<T> getAll();
53     /**
54      * HQL查询
55      * @param hql
56      * @return
57      */
58     public List<T> getAllByHql(String hql);
59     /**
60      * QBC查询
61      * @param criterion
62      * @return
63      */
64     public List<T> getAllByCriteria(Criterion criterion);
65     /**
66      * QBE查询
67      * @return
68      */
69     public List<T> getAllByExample(T t,boolean enableLike,String properties);
70     /**
71      * 默认的QBE查询
72      * @param t
73      * @return
74      */
75     public List<T> getAllByExample(T t);
76 }
77 

下面是BaseDAO类：

BaseDAO.java
  1 /**
  2  * @(#)BaseDAO.java 2009-9-14 下午03:26:46
  3  * Copyright 2009 Bobby_Guo, Inc. All rights reserved
  4  */
  5 package cn.commonframework.util;
  6 
  7 import java.io.Serializable;
  8 import java.util.List;
  9 import org.hibernate.criterion.Criterion;
 10 import org.hibernate.criterion.DetachedCriteria;
 11 import org.hibernate.criterion.Example;
 12 import org.hibernate.criterion.MatchMode;
 13 import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
 14 
 15 /**
 16  * DAO基类，实现公用DAO接口，提供基本的数据库操作。采用泛型设计，增强代码的复用性。
 17  * @author  :Bobby_Guo <br>
 18  * @version :1.0    <br>
 19  * @date    :2009-9-14 下午03:26:46 <br>
 20  */
 21 public class BaseDAO<T> extends HibernateDaoSupport implements IBaseDAO<T> {
 22     
 23     /**
 24      * 声明一个实体类
 25      */
 26     private Class<T> entityClass;
 27     /**
 28      * 无参构造方法
 29      */
 30     public BaseDAO(){
 31         
 32     }
 33     /**
 34      * 构造方法 初始化实体类
 35      * @param entityClass
 36      */
 37     public BaseDAO(Class<T> entityClass){
 38         this.entityClass = entityClass;
 39     }
 40     /**
 41      * 删除一个实体对象。
 42      */
 43     public void delete(T t) {
 44         this.getHibernateTemplate().delete(t);
 45         
 46     }
 47     /**
 48      * 根据主键检索实体对象
 49      */
 50     @SuppressWarnings("unchecked")
 51     public T findById(Serializable id) {
 52         return (T) this.getHibernateTemplate().load(entityClass, id);
 53     }
 54     /**
 55      * 查找所有记录。
 56      */
 57     @SuppressWarnings("unchecked")
 58     public List<T> getAll() {
 59         DetachedCriteria criteria =  DetachedCriteria.forClass(entityClass);
 60         
 61         return this.getHibernateTemplate().findByCriteria(criteria);
 62     }
 63     /**
 64      * 保存实体对象
 65      */
 66     public void save(T t) {
 67         
 68             this.getHibernateTemplate().save(t);
 69         
 70         
 71     }
 72     /**
 73      * 更新实体对象
 74      */
 75     public void update(T t) {
 76         this.getHibernateTemplate().update(t);
 77         
 78     }
 79     /**
 80      * 批量更新
 81      */
 82     public int batchUpdate(String hql,Object o){
 83         
 84         return this.getHibernateTemplate().bulkUpdate(hql, o);
 85     }
 86     /**
 87      * QBC查询
 88      */
 89     @SuppressWarnings("unchecked")
 90     public List<T> getAllByCriteria(Criterion criterion) {
 91         DetachedCriteria criteria =  DetachedCriteria.forClass(entityClass);
 92         for(Criterion c : criterion){
 93             criteria.add(c);
 94         }
 95         return this.getHibernateTemplate().findByCriteria(criteria);
 96     }
 97     /**
 98      * QBE查询 enableLike表示是否为模糊查询 properties为模版对象中要除去的属性名称
 99      */
100     public List<T> getAllByExample(T t, boolean enableLike,
101             String properties) {
102         Example example = null;
103         if(enableLike){
104              example = Example.create(t).ignoreCase().enableLike(MatchMode.ANYWHERE).excludeZeroes();
105         }else{
106              example = Example.create(t);
107         }
108         for(String s : properties){
109             example.excludeProperty(s);
110         }
111         return this.getAllByCriteria(example);
112     }
113     /**
114      * HQL查询
115      */
116     @SuppressWarnings("unchecked")
117     public List<T> getAllByHql(String hql) {
118         
119         return this.getHibernateTemplate().find(hql);
120     }
121     /**
122      * QBE查询 精确查询
123      */
124     @SuppressWarnings("unchecked")
125     public List<T> getAllByExample(T t){
126         return this.getHibernateTemplate().findByExample(t);
127     }
128 
129 }
130

　　 首先注意到的是，XSL文件本身即是一份 XML文件，所以在XSL文件的开头，一样有和XML文件相同的声明。W3C这个XML的标准机构为XSL定义了很多标记（元素），XSL文件就是这些标记和HTML标记的组合。在XSL文件中，必须有如下一行的代码：

　　 ＜xsl:stylesheet xmlns:xsl="http://www.w3.org/TR/WD-xsl"＞

　　 这里，xsl:stylesheet是XSL文件的根元素，在根元素中包含了所有的排版样式，样式表就是由这些排版样式组合成的；xmlns:xsl="http://www.w3.org/TR/WD-xsl"这一句主要用来说明该XSL样式表是使用W3C所制定的XSL，设定值就是XSL规范所在的URL地址。

　　 实际上，这里"http://www.w3.org/TR/WD-xsl"就是一个名字空间（namespace），我们在上面关于XML Schema语法介绍的时候已经进行过介绍。这是一个标准的名字空间。"stylesheet"，"template"，"for-each"等等关键字都是这个名字空间所定义的。

　　 当然在xsl:stylesheet还可以设定其他的属性，其他的属性有：

　　　 1． default-space：决定是否保留XML文件中的空白，仅当值为"default"时保留。

　　　 2． indent-result：决定是否保留XSL文件中的空白，值为"yes"时保留。

　　　 3． language：设定在XSL文件中使用的脚本语言。

　　 然后，我们在上面的代码中看到有如下的代码：

　　 ＜xsl:template match="/"＞
　　　 ………
　　 ＜/xsl:template＞

　　 这里实际上是表示了XSL解析器对XML文档的处理过程，它从根节点（由match="/"决定，这里"/"就表示根节点）开始，对XML文档进行遍历，并根据具体的代码从XML文档中取出相关的内容。这里关于属性match的取值是一个比较复杂的问题。它实际上表示的含义是从XML文档中取出一个特定的节点集合（XML文档可以被看成一个树的结构，这个在后面关于XML解析器分析中有详细的介绍）。这里，我们通过几个简单的例子来说明属性match的取值。

　　 比如下面一行代码：

　　 ＜xsl:template match="/"＞

　　 这行代码的意思是告诉XSL解析程序，当前需要处理的节点是根节点下的内容（用"/"来表示根节点），其实这里的match值内容的编写是要符合XPath的语意。关于XPath我们在后面的章节中会进行详细的介绍。

　　 再举一个例子：

　　 ＜xsl:template match="shoppingcart/item"＞

　　 这行代码要匹配的是shoppingcart元素下的item元素。而不管shoppingcart在XML文档结构树下的哪一个位置。比如XML文档的其中一段是这样的。

　　 ＜shoppingcart＞
　　 ＜item＞
　　 ＜itemNo＞3333＜/itemNo＞
　　 ＜itemName＞屠龙刀＜/itemName＞
　　 ＜/item＞
　　 ＜item＞
　　 ＜itemNo＞4444＜/itemNo＞
　　 ＜itemName＞离别钩＜/itemName＞
　　 ＜/item＞
　　 ＜/shoppingcart＞

　　 那么它匹配的内容就是
　　　 ＜item＞
　　　 ＜itemNo＞3333＜/itemNo＞
　　　 ＜itemName＞屠龙刀＜/itemName＞
　　　 ＜/item＞
　　　 ＜item＞
　　　 ＜itemNo＞4444＜/itemNo＞
　　　 ＜itemName＞离别钩＜/itemName＞
　　　 ＜/item＞

　　 而下面这个例子：

　　 ＜xsl:template match="/shoppingcart/item"＞

表示只匹配XML文档根节点下的shoppingcart这个节点下的所有item元素。也就是说如果shoppingcart不是直接在根节点下的，它就不符合这个匹配条件。

　　 再看一个例子：

　　 ＜xsl:template match="price[@unit='USD']"＞

这个例子说明要匹配的是这样的节点：一个带unit属性的元素price，而且unit的值必须为"USD"。比如一段XML代码是这样的。

　　 ＜price＞
　　　 ＜unit＞USD＜/unit＞
　　　 ＜amount＞100＜/amount＞
　　 ＜/price＞
　　 ＜price＞
　　　 ＜unit＞RMB＜/unit＞
　　　 ＜amount＞300＜/amount＞
　　 ＜/price＞

　　 那么它匹配的内容就是：

　　 ＜price＞
　　　 ＜unit＞USD＜/unit＞
　　　 ＜amount＞100＜/amount＞
　　 ＜/price＞

　　 实际上，存在许多各种符号用来表示匹配规则，我们在XPath语法介绍中会详细涉及到。现在知道这么一个大概的概念就可以了。

　　 我们用＜xsl:template match="具体匹配表达式"＞这条语句找到了一些节点集合以后，我们就要从这个集合中找到特定的元素或者元素属性的值，那么采用什么语句呢？就是用xsl:value-of select = ""这样的语句来寻找特定的内容。

　　 比如下面的例子中＜xsl:value-of select="名称"/＞这行代码就是表示定位XML文档中的名称元素的内容。在指定集合中可能存在多个名字元素，如果我们需要把它们一一列举出来进行处理的话，就需要用到语句xsl:for-each select = ""，注意这里涉及到一个作用范围的概念，也就是说xsl:for-each select = ""这条语句是在一个指定的集合空间中执行的。比如上面例子中如下的代码

　　 这里的＜xsl:for-each select="词语"＞是在＜xsl:template match="网络用语集合"＞所指定的集合空间里面寻找元素"词语"的。

　　 同时，我们需要注意的是上面的代码中，出现了一条语句

　　　 ＜xsl:apply-templates select="网络用语集合" /＞

　　 它表示什么意思呢，它实际上相当于C++中的一个过程调用，当XSL解析器执行到该语句的时候，它就会在代码中寻找以＜?xml:namespace prefix = xsl /＞＜xsl:template match="网络用语集合"＞开头的代码，所以在上面的例子程序中，以下的代码可以看成是过程的实现。

　　 把看成是一个过程调用，把＜xsl:template match="网络用语集合"＞

　　 …….
　　 ＜/xsl:template＞

　　 看成是过程的实现，有助于我们对XSL解析器执行过程的理解。这里match="网络用语集合"可以理解为是传递给过程的参数，它表示过程实现体的集合范围是该match所匹配的节点集合空间（"网络用语集合"）。

　　 如果我们要对表格中的元素进行排序该什么办呢？比如说，在上面的例子中，我们需要按照名称进行排序。很简单对，改写为如下的形式即可：

　　 ＜xsl:for-each select="词语" order-by="+名称"＞，其中"+"表示按降序排列；"-"表示按升序排列。"order-by"是XSL语法中的关键字。

　　 如果我们只想在列表中取出某几行该怎么操作呢？比如我们只想取出名称为"恐龙"的行，见下面的代码：

　　 这里有一个新的句法为：＜xsl:template match="网络用语集合"＞
　　 ＜table Border="1"＞
　　　 ＜xsl:for-each select="词语" order-by="-名称"＞
　　　 ＜xsl:if test=".[名称='恐龙']"＞
　　　 ＜tr＞
　　　　 ＜td＞＜xsl:value-of select="名称"/＞＜/td＞
　　　　 ＜td＞＜xsl:value-of select="含义"/＞＜/td＞
　　　 ＜/xsl:if＞
　　　 ＜/xsl:for-each＞
　　 ＜/table＞
　　 ＜/xsl:template＞

　　 它表示如果".[名称='恐龙']"为真（TRUE）的话，就执行该段里面的语句，要是为假（FALSE）的话就不执行。它和C++中的if语句的概念基本是一样的。

　　 前面我们用＜xsl:value-of select=""/＞取出的都是一个元素的值，但是我们要取出元素某一个属性的值该怎么做呢？采用下面的形式：

　　 ＜xsl:value-of select="元素名称/@属性名称"/＞

　　 比如一段XML代码是这样的：

　　 ＜王朔 网址="www.wangshuo.com"＞知名作家加著名评论家王朔先生的地方＜/王朔＞

　　 我们可以用＜xsl:value-of select="王朔/@网址"/＞来得到值"www.wangshuo.com"。

　　 以上包括了XSL的大多数基本的语法，更加详细和完整的介绍需要参看W3C相关的最新的文档，可以在WWW.W3C.ORG/TR下找到。

　　 根据上面的分析，我们可以看到XSL实际上采用的是一种转换的思想，它最终将XML文档转换为另一种可用于输出的文档，而CSS则没有任何转换动作，在整个过程中没有任何新码产生。 另外，在XSL中90%的样式规定在CSS中都有定义，但仍然有一些效果是CSS无法描述的，必须使用XSL不可。这些功能包括文本的置换、根据文本内容决定显示方式、文档内容排序等，都是XSL所独有的。再者，XSL遵从XML的语法，而CSS的语法自成体系。

　　 选择样式单还要考虑不同浏览器对样式单的支持程度。目前IE5与Netscape的最新版本都支持CSS，但支持的程度都有限。至今为止，IE5尚不能完全支持CSS1，即便是支持的部分也存在很多错误，对于CSS2也只提供部分支持。Netscape在对CSS的支持上已经优于IE5，它采用新一代的Raptor/Gecko引擎技术，已经能够完全支持CSS1，但对CSS2的支持计划尚不明朗。而对XSLT而言，只有IE5支持，Netscape5并不支持。
 

XSLT 是什么类型的语言，其用途是什么，为什么要这样设计它？这些问题可以有许多不同的答案，初学者往往会感到困惑，因为这种语言与他们以前习惯使用的语言之间有很大差别。本文尝试说明 XSLT。本文并不试图教您编写 XSLT 样式表，它将说明这种语言的起源，它擅长什么，以及您为什么应该使用它。

什么是 XSLT？
XSLT 语言由万维网联盟 (W3C) 定义，并且该语言的 1.0 版本在 1999 年 11 月 16 日作为“推荐书”发布（请参阅参考资料）。我已经在拙作 XSLT Programmers' Reference 中提供了全面的规范和用户指南，因此我不打算在本文中涵盖相同内容。确切地讲，本文的目的只是使读者理解 XSLT 适合大规模事物的哪些位置。

XSLT 的角色
XSLT 的最初目的是将信息内容与 Web 显示分离。如其最初定义那样，HTML 通过按抽象概念（如段落、重点和编号列表）定义显示来实现设备独立性。随着 Web 变得越来越商业化，出版人希望其输出质量能达到与印刷品相同的质量。这逐渐导致越来越多地使用具体显示控件，如页面上材料的明确字体和绝对位置。然而不幸的是完全可以预料其副作用，即将相同的内容传递到替代设备，如数字电视机和 WAP 电话（印刷业的行话再现效果）将会变得日益困难。

由于吸收了印刷业使用 SGML 的经验，在 1998 年初定义了一种标记语言 XML，它用于表示独立于显示的结构化内容。与 HTML 使用一组固定概念（如段落、列表和表）不同，XML 标记中使用的标记完全是用户定义的，其用意是这些标记应该与所关注的对象（如人、地点、价格和日期）相关。尽管 HTML 中的元素本质上都是印刷样式（虽然处于抽象级别），而 XML 的目标是元素应该描述实际对象。例如，清单 1 显示了表示足球锦标赛结果的 XML 文档。

清单 1. 表示足球锦标赛结果的 XML 文档
<results group="A">
<match>
<date>10-Jun-1998</date>
<team score="2">Brazil</team>
<team score="1">Scotland</team>
</match>
<match>
<date>10-Jun-1998</date>
<team score="2">Morocco</team>
<team score="2">Norway</team>
</match>
<match>
<date>16-Jun-1998</date>
<team score="1">Scotland</team>
<team score="1">Norway</team>
</match>
<match>
<date>16-Jun-1998</date>
<team score="3">Brazil</team>
<team score="0">Morocco</team>
</match>
<match>
<date>23-Jun-1998</date>
<team score="1">Brazil</team>
<team score="2">Norway</team>
</match>
<match>
<date>23-Jun-1998</date>
<team score="0">Scotland</team>
<team score="3">Morocco</team>
</match>
</results>




如果要通过 Web 浏览器显示这些足球赛的结果，不要指望系统会产生合理的布局。需要其它一些机制来告诉系统如何在浏览器屏幕、电视机、WAP 电话或真正在纸张上显示数据。这就是使用样式表的目的。样式表是一组说明性的规则，它定义了应如何表示源文档中标记标识的信息元素。

W3C 已经定义了两个系列的样式表标准。第一个是在 HTML 中广泛使用的 CSS（级联样式表），当然它也可以在 XML 中使用。例如，可以使用 CSS 来表示何时显示发票，应支付的总额应该用 16 点 Helvetica 粗体字显示。但是，CSS 不能执行计算、重新整理或排序数据、组合多个源码中的数据或根据用户或会话的特征个性化显示的内容。在这个足球赛结果的例子中，CSS 语言（即使是最新版本 CSS2，尚未在产品中完全实现）的功能还不够强大，不能处理这项任务。由于这些原因，W3C 已着手开发更强大的样式表语言 XSL（可扩展样式表语言），并采纳了 SGML 社区中开发的 DSSSL（文档样式、语义和规范语言）中许多好的构思。

在 XSL 的开发过程中（这在 DSSSL 中已有所预示），发现在准备 XML 文档以备显示的过程中执行的任务可以分成两个阶段：转换和格式化。转换是将一个 XML 文档（或其内存中的表示法）转换成另一个 XML 文档的过程。格式是将已转换的树状结构转换成两维图形表示法或可能是一维音频流的过程。XSLT 是为控制第一阶段“转换”而开发的语言。第二阶段“格式化”的开发工作还是进行中。但实际上，大多数人现在使用 XSL 将 XML 文档转换成 HTML，并使用 HTML 浏览器作为格式化引擎。这是可行的，因为 HTML 实际上只是 XML 词汇表的一个示例，而 XSLT 可以使用任何 XML 词汇表作为其目标。

将转换成一种语言和格式化成另一种语言这两个操作分离经证实的确是一种好的决策，因为转换语言的许多应用程序经证明无法向用户显示文档。随着 XML 日益广泛地用作电子商务中的数据互换语法，对于应用程序将数据从一个 XML 词汇表转换成另一个 XML 词汇表的需求也在不断增加。例如，某个应用程序可能从电视收视指南中抽取电视节目的细节，并将它们插入按次付费客户的月帐单中。同样，还有许多实用的数据转换，在这些转换中源词汇表和目标词汇表是相同的。它们包括数据过滤，以及商务操作，如施行涨价。因此，随着在系统中开始越来越多地以 XML 语法的形式使用数据，XSLT 就逐渐成为由于处理这些数据的随处可见的高级语言。

在拙作中，我做了这样一个比喻：XSLT 与 XML 的关系，就好象 SQL 与表格化数据的关系一样。关系模型的强大功能并非来自用表存储数据的思想，而是源于 SQL 中可行的基于关系运算的高级数据操作。同样，XML 的层次化数据模型对应用程序开发者的帮助实际上也非常小。正是因为 XSLT 作为 XML 数据的高级操作语言提供了如此强大的功能。

XSLT 作为语言
就某些方面而言，XSLT 作为一种语言来说是非常古怪的。我不打算在本文中讨论已做出的设计决策的基本原理，尽管可以通过它们在逻辑上追溯到语言设计者确定的对 XSLT 的要求。

以下概述了 XSLT 语言的部分主要特性。

XSLT 样式表是一个 XML 文档。通过使用 XML 的尖括号标记语法来表示文档的结构。这种语法在某种程度上是比较笨拙的，而此决策可以使该语言变得更罗嗦。但是，它确实有好处。它表示可以自动使用 XML 的所有词汇设备（例如，Unicode 字符编码和转义，使用外部实体等等）。它表示很容易使 XSLT 样式表变成转换的输入或输出，使该语言可以作用于自身。它还使将期望的 XML 输出块嵌入样式表变得很容易。实际上，许多简单的样式表基本上可以写作期望输出文档的模板，并且可以将一些特殊指令嵌入文本中，以便插入输入中的变量数据或计算某个值。这就使 XSLT 在这个简单的级别上非常类似于许多现有的专用 HTML 模板语言。

基本处理范例是模式匹配。在这方面，XSLT 继承了文本处理语言（如 Perl）的传统，这种传统可以一直追溯到 1960 年代的语言，如 SNOBOL。XSLT 样式表包括一组模板规则，每条规则都使用以下方式：“如果在输入中遇到此条件，则生成下列输出。”规则的顺序是无关紧要的，当有几条规则匹配同一个输入时，将应用冲突解决算法。然而，XSLT 与串行文本处理语言的不同之处是 XSLT 对输入并非逐行进行处理。实际上，XSLT 将输入 XML 文档视为树状结构，每条模板规则都适用于树中的一个节点。模板规则本身可以决定下一步处理哪些节点，因此不必按输入文档的原始顺序来扫描输入。

XSLT 处理器的操作
XSLT 处理器使用树状结构作为其输入，并生成另一个树状结构作为输出。

常常通过对 XML 文档进行语法分析来生成输入树状结构，而输出树状结构通常被串行化到另一个 XML 文档中。但 XSLT 处理器本身操作的是树状结构，而不是 XML 字符流。这个概念最初给许多用户的感觉是不切实际的，结果却对理解如何执行更复杂的转换起了关键作用。首先，它表示 XSLT 处理器可以理解源文档中与树状结构无关的特殊之处。例如，无论属性是包括在单引号中还是在双引号中，都不可能应用不同的处理，因为会将这两种形式视为同一个基本文档的不同表示方法。更深入地看，它表示处理输入元素或生成输出元素是一个原子操作。不可能将处理元素的开始标记和结束标记分成单独的操作，因为一个元素会自动表示成树模型的单节点。

XSLT 使用叫作 XPath 的子语言来引用输入树中的节点。XPath 本质上是与具有层次结构的 XML 数据模型相匹配的查询语言。它可以通过按任何方向浏览树来选择节点，并根据节点的值和位置应用谓词。它还包括用于基本字符串处理、数字计算和布尔代数的工具。例如，XPath 表达式 ../@title 选择当前节点的父代元素的标题属性。XPath 表达式用于选择要进行处理的输入节点、在条件处理期间测试条件，以及计算值以便插入结果树中。模板规则中还使用了 XPath 表达式的简化形式“模式”来定义特定模板规则适用于哪些节点。XPath 在单独的 W3C 推荐书中定义，它允许使用在其它上下文中再使用的查询语言，特别是用于定义扩展超链接的 XPointer。

XSLT 以传统语言（如 Lisp、Haskell 和 Scheme）中的功能性编程的概念为基础。样式表由模板组成，这些模板基本上是单一功能 -- 每个模板将输出树的一部分定义成一部分输入树的功能，并且不产生副作用。使用无副作用的规则受到严格控制（除了转义成用类似 Java 的语言编写的外部代码）。XSLT 语言允许定义变量，但不允许现有变量更改它的值 -- 即没有赋值语句。这个策略使许多新用户感到困惑，其目的是为了允许逐步应用样式表。其原理是如果语言没有副作用，那么对输入文档做很小的改动时，不必从头执行整个转换就应该可以计算出对输出文档的最后更改。目前必须说这只是理论上的可能，任何现有 XSLT 处理器还不能实现。（注：虽然 XSLT 以功能性编程概念为基础，但它还不是一个完整的功能性编程语言，因为它缺少将函数当作一级数据类型进行处理的能力。）

示例样式表
在这个阶段，使用示例会使语言变得更清楚。清单 2 显示了列出足球赛结果的简单样式表。

清单 2. 足球赛结果的基本样式表

<xsl:transform
xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">

<xsl:template match="results">
<html>
<head><title>
Results of Group <xsl:value-of select="@group">
</title></head>
<body><h1>
Results of Group <xsl:value-of select="@group">
</h1>
<xsl:apply-templates>
</body></html>
</xsl:template>

<xsl:template match="match">
<h2>
<xsl:value-of select="team[1]"> versus <xsl:value-of select="team[2]">
</h2>
<p>Played on <xsl:value-of select="date"></p>
<p>Result:
<xsl:value-of select="team[1] ">
<xsl:value-of select="team[1]/@score">,
<xsl:value-of select="team[2] ">
<xsl:value-of select="team[2]/@score">
</p>
</xsl:template>

</xsl:transform>





这个样式表包括两个模板规则，一个匹配 <results> 元素，另一个匹配 <match> 元素。<results> 元素的模板规则输出页面的标题，然后调用 <xsl:apply-templates>，这是一个 XSLT 指令，它将处理当前元素的所有子代，对于每个子代都使用其适当的模板规则。在本例中，<results> 元素的所有子代都是 <match> 元素，所以会用第二个模板规则来处理它们。规则输出了一个标识比赛的次级 HTML 标题（以 "Brazil versus Scotland" 的形式），然后生成 HTML 段落，给出了比赛的日期和两队的比分。

该转换的结果就是一个 HTML 文档。

这是一种非常简单的表示信息的方法。然而，XSLT 的功能比这要强大得多。清单 3 包含了另一个可以操作相同源数据的样式表。这次，样式表计算一个比赛名次表，用来显示锦标赛结束时各队的名次。

清单3. 计算球队名次表的样式表
<xsl:transform
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
version="1.0">


<xsl:variable name="teams" select="//team[not(.=preceding::team)]">
<xsl:variable name="matches" select="//match">

<xsl:template match="results">

<html><body>
<h1>Results of Group <xsl:value-of select="@group"></h1>

<table cellpadding="5">
<tr>
<td>Team</td>
<td>Played</td>
<td>Won</td>
<td>Drawn</td>
<td>Lost</td>
<td>For</td>
<td>Against</td>
</tr>
<xsl:for-each select="$teams">
<xsl:variable name="this" select=".">
<xsl:variable name="played" select="count($matches[team=$this])">

<xsl:variable name="won"
select="count($matches[team[.=$this]/@score > team[.!=$this]/@score])">
<xsl:variable name="lost"
select="count($matches[team[.=$this]/@score < team[.!=$this]/@score])">
<xsl:variable name="drawn"
select="count($matches[team[.=$this]/@score = team[.!=$this]/@score])">
<xsl:variable name="for"
select="sum($matches/team[.=current()]/@score)">
<xsl:variable name="against"
select="sum($matches[team=current()]/team/@score) - $for">

<tr>
<td><xsl:value-of select="."></td>
<td><xsl:value-of select="$played"></td>
<td><xsl:value-of select="$won"></td>
<td><xsl:value-of select="$drawn"></td>
<td><xsl:value-of select="$lost"></td>
<td><xsl:value-of select="$for"></td>
<td><xsl:value-of select="$against"></td>
</tr>
</xsl:for-each>
</table>
</body></html>
</xsl:template>

</xsl:transform>





这里没有足够的篇幅来完整地说明这个样式表，简而言之，它为球队声明了一个变量，变量值是一个节点集合，其中每个参赛球队都有一个实例。然后它计算每支球队的盛、平或负的比赛场次总数，以及球队进球或失球的总数。

这个示例的目的是说明 XSLT 不单单能够对源文档中出现的文本指定字体和布局。它是一个完整的编程语言，能够以任何方式转换源数据以供显示，或者输入另一个应用程序。

XSLT 的优点
您为什么考虑使用 XSLT？

XSLT 给了您传统高级声明编程语言的所有好处，特别是对于转换 XML 文档的任务。

高级语言带来的实际好处是开发生产力。但实际上，真正的价值源自于更改的潜力。与使用低级 DOM 和 SAX 接口编码的过程性应用程序相比，用于转换 XML 数据结构的 XSLT 应用程序更能适应对 XML 文档细节的更改。在数据库世界中，这种特性叫做数据独立性，正是由于数据独立性导致了诸如 SQL 之类声明性语言的成功，并使旧的引导性数据访问语言走向衰亡。我坚信在 XML 世界中也会这样。

当然与所有声明性语言一样，XSLT 也会降低性能。但是对于大多数应用程序，今天的 XSLT 处理器的性能已经完全能够满足应用程序的需要，并且它会变得越来越好。