Lucene是apache组织的一个用java实现全文搜索引擎的开源项目。

其功能非常的强大，api也很简单。总得来说用Lucene来进行建立

和搜索和操作数据库是差不多的(有点像)，Document可以看作是

数据库的一行记录，Field可以看作是数据库的字段。用lucene实

现搜索引擎就像用JDBC实现连接数据库一样简单。

Lucene2.0，它与以前广泛应用和介绍的Lucene 1.4.3并不兼容。

Lucene2.0的下载地址是http://apache.justdn.org/lucene/java/

大家先看一个例子，通过这个例子来对 lucene 的一个大概的认识。

一个 Junit 测试用例： ( 为了让代码清晰好看，我们将异常都抛出 )

a)    这是一个建立文件索引的例子

public void testIndexHello() throws IOException

    {

        Date date1 = new Date();  

        // 可以说是创建一个新的写入工具

        // 第一个参数是要索引建立在哪个目录里

        // 第二个参数是新建一个文本分析器,这里用的是标准的大家也可以自己写一个

        // 第三个参数如果是true，在建立索引之前先将c:\\index目录清空。

        IndexWriter writer = new IndexWriter( "c:\\index" , new StandardAnalyzer(), true );

//      这个是数据源的文件夹

        File file = new File( "c:\\file" );

        /**

          * 例子主要是将C:\\file目录下的文件的内容进行建立索引，将文件路径作为搜索内容的附属.

          */

        if (file.isDirectory())

        {

            String[] fileList = file.list();

            for ( int i = 0; i < fileList. length ; i++)

            {

//              建立一个新的文档,它可以看作是数据库的一行记录

                Document doc = new Document();

                File f = new File(file,

                        fileList[i]);

                Reader reader = new BufferedReader( new FileReader(f));

                doc.add( new Field( "file" ,reader)); // 为doument添加field

                doc.add( new Field( "path" ,f.getAbsolutePath(),Field.Store. YES ,Field.Index. NO ));

                writer.addDocument(doc);

            }

        }

        writer.close(); // 这一步是必须的，只有这样数据才会被写入索引的目录里

        Date date2 = new Date();

        System. out .println( " 用时" +(date2.getTime()-date1.getTime())+ " 毫秒" );

}

注意：因为建立索引本来就是费时，所以说最后输出的用时会比较长，请不要奇怪。

b) 一个通过索引来全文检索的例子

public void HelloSearch() throws IOException, ParseException

    {

        IndexSearcher indexSearcher = new IndexSearcher( "c:\\index" ); // 和上面的IndexWriter一样是一个工具

        QueryParser queryParser = new QueryParser( "file" , // 这是一个分词器

                new StandardAnalyzer());

        BufferedReader br = new BufferedReader( new InputStreamReader(System. in ));

        Query query = queryParser.parse(br.readLine()); // 这个地方Query是抽象类大家也注意一下，下面会讲到的

        Hits hits = indexSearcher.search(query);

        Document doc = null ;

        System. out .print( " 正搜索................" );

        for ( int i = 0; i < hits.length(); i++)

        {

            doc = hits.doc(i);

            System. out .println( " 内容是：" +doc.get( "file" )); // 注意这里输出的是什么

            System. out .println( " 文件的路径是：" + doc.get( "path" ));

        }

    }

通过上面的两个例子应该可以看出Lucene还是比较简单的。

运行一下上面的两个例子，大家可能会说怎么doc.get( “ file ” ); 返回的是空呢,我们马上会讲到。

下面讲一下索引的建立

其实从上面的例子就可以看出建立索引就用到Document,IndexWriter,Field。

最简单的步骤就是：

首先分别new 一个Document，IndexWriter,Field

然后用Doument.add()方法加入Field,

其次用IndexWrtier.addDocument()方法加入Document。

最后调用一下IndexWriter.close()方法关闭输入索引，这一步非常的重要只有调用这个方法索引才会被写入索引的目录里，而这是被很多初学的人所忽略的。

Document 没有什么好介绍的，把它的作用看成数据库中的一行记录就行。

Field 是一个比较重要的也是比较复杂的：

看一下它的构造函数有5个：

Field (String name, byte[] value, Field.Store store)

Field (String name, Reader reader)

Field (String name, Reader reader, Field.TermVector termVector)

Field (String name, String value, Field.Store store, Field.Index index)

Field (String name, String value, Field.Store store, Field.Index index, Field.TermVector termVector)

在Field中有三个内部类：Field.Index,Field.Store,Field.termVector，而构造函数也用到了它们。

注意： termVector 是Lucene 1.4 新增的它提供一种向量机制来进行模糊查询的这个不常用，默认是false不过是什么对于一般查询无影响。

它们的不同的组合，在全文检索中有着不同的作用。看看下面的表吧:

而对于 Field (String name, Reader reader)

Field (String name, Reader reader, Field.TermVector termVector)

他们是Field.Index.TOKENIZED和Field.Store.NO的。这就是为什么我们在上面的例子中会出现文章的内容为null了。因为它只是被索引了，而并没有被存储下来。如果一定要看到文章的内容的话可以通过文章的路径得到毕竟文章的路径是作为搜索的附属物被搜索出来了。而我们在Web开发的时候一般是将大数据放在数据库中，不会放在文件系统中，更不会放在索引目录里，因为它太大了操作会加大服务器的负担。

下面介绍一下IndexWriter:

它就是一个写入索引的写入器,它的任务比较简单：

1. 用addDocument()将已经准备好写入索引的document们加入

2. 调用close()将索引写入索引目录

先看一下它的构造函数:

IndexWriter (Directory d, Analyzer a, boolean create)

（未完）

1. 解开下载所得文件的ZIP压缩：解开压缩之后就得到了一个soap-2_0子目录。我把ZIP文件的内容解压缩到E盘的根目录下，因此有了一个包含Apache SOAP的E:\soap-2_0目录。
2. 配置Web环境：要有一个支持Servlet和JSP的Web服务器。至此，你可能遇到下面两种情况之一：
   • 情况1：已经有一个支持Servlet和JSP的Web服务器，而且你觉得配置这个服务器没有问题。在这种情况下，请配置服务器，使得浏览器可以访问http://localhost:8080/apache-soap/，打开soap-2_0 \webapps\soap\目录下面的index.html文件。
   • 情况2：没有支持Servlet和JSP的Web服务器，或者虽然有这样一个服务器，却不想拿它做试验。在这种情况下，我建议你下载Tomcat的最新版本（写作本文时，最新版本是3.1）（参见“参考资源”中的链接）。Tomcat是Apache创建和免费提供给软件开发者的又一个优秀软件。下载合适的ZIP文件之后（jakarta-tomcat-3.1.1.zip），解开压缩时创建一个jakarta-tomcat子目录。和前面相似，我把解压缩得到的文件放入E盘的根目录之下。在jakarta-tomcat\conf\server.xml配置文件中增加一个新的<Context>标记，如下所示：

     <Context path="/apache-soap" docBase="E:/soap-2_0/webapps/soap" debug="1" reloadable="true"> </Context>

     在Context元素的docBase属性中，你应该在指定soap-2_0目录时把E:替换成合适的盘符。要启动Tomcat，执行startup.bat（对于Unix，执行startup.sh）。要关闭Tomcat，执行shutdown.bat（对于Unix，执行shutdown.sh）。但请稍等——现在请不要启动Tomcat。
3. 设置Web服务器classpath：Apache SOAP要求有1.1.2版本或更高的Apache Xerces（Java），它支持DOM（文档对象模型）Level 2规范，支持名称空间。我使用1.2版本的Xerces，即Apache网站的Xerces-J-bin.1.2.0.zip。解开这个压缩文件，得到xerces-1_2_0子目录。和前面一样，我把解压缩得到的文件放到了E:盘的根目录之下。你应该配置Web服务器，使它能够用xerces.jar（它在xerces-1_2_0子目录下）进行所有XML解析——而不是用服务器附带的库或jar解析XML。例如，Tomcat附带了一个XML解析器（jakarta-tomcat\lib\xml.jar），支持DOM Level 1接口。即使你把xerces.jar放入了classpath，Tomcat下运行的Java代码也可能找错接口，因为在用来启动Tomcat的Shell脚本/批命令文件中，xerces.jar被放到了classpath的最后。因此，必须编辑jakarta-tomcat\bin目录下的tomcat.bat（对于Unix，则是tomcat.sh），把xerces.jar放到classpath的前面。下面是我在jakarta-tomcat\bin\tomcat.bat文件中所作的修改：

   set CLASSPATH=E:\xerces-1_2_0\xerces.jar;%CLASSPATH%;%cp%

图一：Web界面的Apache SOAP管理工具

看看demo是最有说服力的了，按下面的操作进入demo(居然没有直达的链接！)：

1. 点击下面的链接，进入主页：

   http://dojotoolkit.org/

2. 点击上面的 seeitinaction 标签，这里分门别类罗列了各种例子

jsLINB--国人写的一个完整web2.0技术框架。jsLINB的在线demo：http://www.linb.net/linb/，里面包括变量类型检测、强制类型变量、javascript线程实现、完美OO模型、基于dom id的事件系统实现、dom元素的“随动”实现、高级托拽、sorted grid控件、tree grid控件等等。 http://www.linb.net/linb/#102002 jsLINB框架图 http://www.linb.net/linb/#102101001 变量类型检测 http://www.linb.net/linb/#102101002 强制类型变量 http://www.linb.net/linb/#102101003 javascript线程实现 http://www.linb.net/linb/#102101103 36位guid http://www.linb.net/linb/#102105001 基于dom id的事件系统实现 http://www.linb.net/linb/#102105002 dom元素的“随动”实现 http://www.linb.net/linb/#102106002001 基本拖拽 http://www.linb.net/linb/#102106002002 限制拖拽 http://www.linb.net/linb/#102106002003 拖拽任何domnode http://www.linb.net/linb/#102106002004 网格拖拽 http://www.linb.net/linb/#102106002005 停靠拖拽 http://www.linb.net/linb/#102106002006 多handle拖拽 http://www.linb.net/linb/#102106002007 图标代理拖拽 http://www.linb.net/linb/#102106002008 多目标drop http://www.linb.net/linb/#102109001 快速html生成 http://www.linb.net/linb/#102109002 DOM控制封装 http://www.linb.net/linb/#102109004 基于线程的特效 http://www.linb.net/linb/#102010 直接调用 http://www.linb.net/linb/#102011 完美OO实现 http://www.linb.net/linb/#203004003 Treebar控件 http://www.linb.net/linb/#203005003001 sorted grid控件 http://www.linb.net/linb/#203005003002 tree grid控件 http://www.linb.net/linb/#203007003 window控件

       Dwr 通过用户配置文件 dwr.xml 将 java 类映射成一个 javascript 对象，从实现手法上看与 java 里的数据映射很相似。而 dwr 是将 JAVA 的对象映射到了 js 里，由客户端的 JS 提供给用户各类实现，而 java 代码完全在后台运行。

       DWR 函数调用里涉及到的 JS 代码： engine.js

       DWR 函数调用里涉及到的类有： AbstractDWRServlet 、 DefaultProcessor

用户在提交 request 以后的操作步骤请参见我 blog 里的：《 dwr 源码学习（一）》， JAVA 代码生成的映射 JS 代码其实只是一个 javascript 接口，它调用了 DWREngine._execute 这个函数，而这个函数大体只是执行了一些解析的工作，在它结尾处调用了 DWREngine.endBatch() ，然后又执行了 DWREngine._sendData(batch) ，这时我们会发现有这样一句： “ batch.req.open("GET", batch.path + "/exec/" + statsInfo + "?" + query, batch.async); ”很熟悉吧。

    下一步就到了真正的实现 js 调用 java 代码里方法的时候了，兴奋吧。其实实现也是很简单的。通过 servlet 这里实现了对各类型 request 参数的不同的匹配，还是看 AbstractDWRServlet .getPost() 这个方法：

也就只有这几种类型的请求，还记得 DWREngine._sendData 吗？里面有这么一句：“ batch.req.open("GET", batch.path + "/exec/" + statsInfo + "?" + query, batch.async); ”看到他的请求路径是 exec ，对应在 processor.handle(req, resp); 这个方法里就是 exec ，在刚才的 JAVA 代码里我们已经看到过了是括号内的代码（ else if (pathInfo.startsWith(HtmlConstants. PATH_EXEC )) ），而 exec 早已在 servlet 初始化的时候就已经设置为 DefaultExecProcessor ，它的函数 hadle() 就是具体对 js 调用 java 类方法的实现了。

DWR 是一个小型的 AJAX 框架，它的实现思路简单，其实有很多人在开发中一定也有过类似的想法。它之所以现在才出现我想大概还是要归功于异步 javascript 消息发送这样的技术成为现实。所以我又想 AJAX ，从技术上说只能是 javascript 有了一个飞跃性的进步，而 AJAX 的最终成功却要靠软件工程。

Java 程序

通过使用上述步骤中用过的三个工具的 DOM API ，我接下来会展示一个 JAVA 程序。它在运行时需要提供两个命令行参数，会自动生成相应的 PDF 文档，并且不会产生任何临时文件。

第一个程序新建一个 HTML 文件的 InputStream 对象，然后此对象被传给 JTidy 。

JTidy 有个方法叫 parseDOM() ，可以用来生成输出的 XHTML 文档的 Document 对象。

    public static void main(String[] args) {

    // 打开文件

    if (args.length != 2) {

        System.out.println("Usage: Html2Pdf htmlFile styleSheet");

        System.exit(1);

    }

    FileInputStream input = null;

    String htmlFileName = args[0];

    try {

        input = new FileInputStream(htmlFileName);

    }

    catch (java.io.FileNotFoundException e) {

        System.out.println("File not found: " + htmlFileName);

    }

        Tidy tidy = new Tidy();

    Document xmlDoc = tidy.parseDOM(input, null);

JTidy 的 DOM 实现并不支持 XML 命名空间。因此，我们必需修改 Antenna House 的样式表，让它使用默认的命名空间。比如，原来是：

    <xsl:template match="html:h2">

      <fo:block xsl:use-attribute-sets="h2">

         <xsl:call-template name="process-common-attributes-and-children"/>

      </fo:block>

    </xsl:template>

被修改后是：

    <xsl:template match="h2">

      <fo:block xsl:use-attribute-sets="h2">

        <xsl:call-template name="process-common-attributes-and-children"/>

      </fo:block>

    </xsl:template>

这个改动必需被应用到 xhtml2f0.xsl 中的所有模板，因为 JTidy 生成的 Document 对象以 <html> 标签作为根，如：

<html xmlns=quot;http://www.w3.org/1999/xhtml">

修改后的 xhtml2fo.xsl 包含在这篇文章附带的源代码中。

接着， xml2FO() 方法调用 Xalan ，使样式表应用于 JTidy 生成的 DOM 对象：

    Document foDoc = xml2FO(xmlDoc, args[1]); 

方法 xml2FO() 首先调用 getTransformer() 来获得一个指定的样式表的 Transformer 对象。然后，代表着转换结果的那个 Document 被返回：

    private static Document xml2FO(Document xml, String styleSheet) {

    DOMSource xmlDomSource = new DOMSource(xml);

          DOMResult domResult = new DOMResult();

    Transformer transformer = getTransformer(styleSheet);

    if (transformer == null) {

        System.out.println("Error creating transformer for " + styleSheet);

        System.exit(1);

    }

    try {

        transformer.transform(xmlDomSource, domResult);

    }

    catch (javax.xml.transform.TransformerException e) {

        return null;

    }

    return (Document) domResult.getNode();

    }

接着， main 方法用与 HTML 输入文件相同的前缀来打开一个 FileOutputStream 。然后调用 fo2PDF() 方法所获得的结果被写入 OutputStream ：

    String pdfFileName = htmlFileName.substring(0, htmlFileName.indexOf(".")) + ".pdf";

    try {

        OutputStream pdf = new FileOutputStream(new File(pdfFileName));

        pdf.write(fo2PDF(foDoc));

    }

    catch (java.io.FileNotFoundException e) {

        System.out.println("Error creating PDF: " + pdfFileName);

    }

    catch (java.io.IOException e) {

        System.out.println("Error writing PDF: " + pdfFileName);

    }

方法 fo2PDF() 会使用在转换中产生的 XSL-FO Document 和一个 ByteArrayOutputStream 来生成一个 FOP driver 对象。通过调用 Driver.run 可以生成 PDF 文件。结果被作为一个 byte array 返回：

    private static byte[] fo2PDF(Document foDocument) {

        DocumentInputSource fopInputSource = new DocumentInputSource(

                                                         foDocument);

        try {

            ByteArrayOutputStream out = new ByteArrayOutputStream();

            Logger log = new ConsoleLogger(ConsoleLogger.LEVEL_WARN);

            Driver driver = new Driver(fopInputSource, out);

            driver.setLogger(log);

            driver.setRenderer(Driver.RENDER_PDF);

            driver.run();

            return out.toByteArray();

        } catch (Exception ex) {

            return null;

        }

    }

Html2Pdf.java 的源代码可以在这篇文章的附带代码中找到。

使用 DOM API 来完成这整个过程，速度要比使用命令行界面快得多，因为它不需要往磁盘中写入任何中间文件。这种方法可以集成到服务器里，来处理并发的 HTML-PDF 转换请求。

以前我曾以这里展示的这个程序为基础把生成 PDF 的功能集成到一个 WEB 应用。而生成 PDF 的过程是动态的，因此不需要考虑 WEB 页面和相应 PDF 同步的问题，因为生成的 PDF 文件并不是存放在服务器上。

结论

综述，在本文里我描述了怎样利用开源组件来实现 HTML 到 PDF 的转换。虽然这种实现方法在价格和源码方面很有吸引力，但同时也有一定的折衷。一些商业组件可以提供更完整的标准实现。

比如说， FOP 目前的版本是 .91 ，不完全支持 XSL-FO 标准。尽管如此，相对其它的格式而言，对 PDF 提供了更多的支持。

在开始一个文档转换的项目之前，你必需考虑对文档格式的需求，并把它们与已有组件所实现的功能做个对比。这将有助于做出正确的决定。

资源

# 下载本文中的源码 :

http://www.javaworld.com/javaworld/jw-04-2006/html/jw-0410-html.zip

# Adobe's Document Server 产品 :

http://www.adobe.com/products/server/documentserver/main.html

# Antenna House ( 出售商业的格式化程序 ):

http://www.antennahouse.com

# xhtml2fo.xsl 把 XHTML 转化为 XSL-FO 的样式表 :

http://www.antennahouse.com/XSLsample/XSLsample.htm

# Apache FOP formatter 把 XSL-FO 翻译为 PDF:

http://xmlgraphics.apache.org/fop

# FOP 对 XSL-FO 标准的兼容性 :

http://xmlgraphics.apache.org/fop/compliance.html

# JTidy ，把 HTML 转化为 XHTML:

http://sourceforge.net/projects/jtidy/

# Xalan:

http://xalan.apache.org/

# XSL-FO, Dave Pawson (O'Reilly Media, 2002 年 8 月 ; ISBN: 0596003552):

http://www.amazon.com/exec/obidos/ASIN/0596003552/javaworld

# XSLT 2.0 Programmer's Reference, Michael Kay (Wrox, 2004 年 8 月 ; ISBN: 0764569090):

http://www.amazon.com/exec/obidos/ASIN/0764569090/javaworld

# 浏览 JavaWorld 的 Development Tools 部分可以找到更多关于 Java 开发工具的文章 :

http://www.javaworld.com/channel_content/jw-tools-index.shtml

# JavaWorld 的 Java 与 XML 部分的文章索引 :

http://www.javaworld.com/channel_content/jw-xml-index.shtml

英文原文：http://www.javaworld.com/javaworld/jw-04-2006/jw-0410-html.html

转自  http://shaofan.blogjava.net

把网页内容以PDF的格式呈献有利于内容的传播。在一些应用中，提供格式便于打印的文档是一个必需的功能，比如员工利益表等。事实上，法律规定Summmary Plan Descriptions(SPDs)必须能够打印，即使它们是在线提供的也是如此。然而只打印网页本身是不够的，因为打印格式必包含表格内容和页码。

为了提供这样的功能，开发人员可以把HTML内容转换为PDF格式。在此即做介绍。这里介绍的这种方法只使用开源组件。一些商业产品也支持动态的文档生成，比如说Adobe，它有Document Server产品线。但是，使用商业产品的开销是相当可观的。使用开源方案可以缓解开销的问题，并增加了组件源码的透明度。

转换过程包含以下三步：

1.把HTML转换为XHTML;

2.把XHTML转换为XSL-FO(Extensible Stylesheet Language Formatting Objects扩展样式表语言格式化对象)。这里使用XSL样式表和XSLT转换器;

3.把XSL-FO文档传递给格式化程序来生成目标PDF文档。

本文先介绍怎样用命令行界面来做这种转换，然后介绍怎样在JAVA中使用DOM接口来做同样的工作。

组件版本：

本文中的代码在以下版本中进行了测试：

组件     版本

JDK     1.5_06

JTidy    r7-dev

Xalan-J  2.7

FOP     0.20.5

使用命令行界面

在转换过程中的每一步都包含了从一个输入文件生成输出文件的过程。这个过程可以用下图来表示：

使用这三个工具的命令行界面开始我们的工作是个好方法，尽管这种方法并不适合产品级的系统，因为它需要往磁盘中写入临时的中间文件。这种额外的I/O会导致性能的降低。稍后，在我们用JAVA来调用这三个工具时，这个问题就会得到解决。

第一步：转换HTML为XHTML

第一步就是把HTML转换为一个新的XHTML文件。当然，如果文件本来已经就是XHTML，那就不需要这一步了。

我用JTidy来完成这个转换。JTidy是Tidy HTML解析器的JAVA版本。在转换的过程中，JTidy会自动添加缺少的标签来创建格式良好(well-formed)的XML文档。我用的是在SourceForge上的最新版本r7-dev。

可以用以下的脚本来运行JTidy：

#/bin/sh

java -classpath lib/Tidy.jar org.w3c.tidy.Tidy -asxml $1 >$2

此脚本设置了CLASSPATH并调用了JTidy。运行时，要输入的文件是以命令行参数的形式传给JTidy。默认情况下，生成的XHTML将被输出到标准输出设备。-modify开关可以用来覆写输入文件。-asxml开关把JTidy的输出重定向到格式良好的XML。

调用时像这样：

tidy.sh hello.html hello.xml

hello.html(输入)和hello.xml(输出)的内容如下：

<html>

<head>

  <title>Hello World

</head>

<body>

   <p> Hello World!

</body>

</html>

<!DOCTYPE html PUBLIC quot;-//W3C//DTD XHTML 1.0 Strict//EN"

    quot;http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns=quot;http://www.w3.org/1999/xhtml">

<head>

<meta name=quot;generator" content="HTML Tidy, see www.w3.org" />

<title>Hello World</title>

</head>

<body>

<p>Hello World!</p>

</body>

</html>

要注意的是，在XML文件中的那个</p>和</title>是JTidy自动添加的[译注1]。

第二步：转换XHTML为XSL-FO[译注2]

下面，XHTML将被转换为XSL-FO，一种用来为XML文档指定打印格式的语言。我通过用XSLT转换器(Apache Xalan)处理XSL样式表来完成这个转换。我使用的样式表是由Antenna House提供的xhtml2fo.xsl。Antenna House是一个出售XSL-FO上商用格式程序的公司。

xhtml2fo.xsl样式表指定了如何把每个HTML标签翻译成相应的XSL-FO格式化命令序列。举例来说，HTML中的H2标签在翻译中被定义为：

    <xsl:template match="html:h2">

      <fo:block xsl:use-attribute-sets="h2">

        <xsl:call-template name="process-common-attributes-and-children"/>

      </fo:block>

    </xsl:template>

在处理的过程中，每次遇到H2标签，以上XSLT模板都会被调用。html:前缀表明H2标签是HTML的命名空间(namespace)。样式表的命名空间在顶层xsl:stylesheet指示符的属性中被指定。在xhtml2fo.xsl的最顶层，我们可以看到它指定了三个命名空间，分别对应于XSL,XSL-FO和HTML语言。

    <xsl:stylesheet version="1.0"

                    xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

                    xmlns:fo="http://www.w3.org/1999/XSL/Format"

                    xmlns:html="http://www.w3.org/1999/xhtml">...

模板中的第二行

    <fo:block xsl:use-attribute-sets="h2">

致使fo:block标签被输出，并且H2的属性被生成为fo:block标签的属性和值。每个XSL-FO块(block)都是一段文字，它们的格式基于块的属性的值。

H2的属性在样式表中被定义为：

    <xsl:attribute-set name="h2">

        <xsl:attribute name="start-indent">10mm

        <xsl:attribute name="end-indent">10mm

        <xsl:attribute name="space-before">1em

        <xsl:attribute name="space-after">0.5em

        <xsl:attribute name="font-size">x-large

        <xsl:attribute name="font-weight">bold

        <xsl:attribute name="color">black

   </xsl:attribute-set>

start-indent及其后的属性用来指定H2块的格式化后的外观。当你想改变PDF文档中用同样HTML标签的文字块的外观时，使用属性集可以使这种改变更加容易。只要改动属性的设置，那么输出的文件中所有使用这些属性的地方都会被改动。

下一个指示符调用一个名为"process-common-attributes-and-children"的模板：

    <xsl:call-template name="process-common-attributes-and-children"/>

这个模板在样式表中被指定。它的作用是检查一些普通的HTML属性(如lang,id,align,valign,style)并生成相应的XSL-FO指示符。要触发对嵌在顶层H2标签中的任意标签的翻译，process-common-attributes-and-children会调用：

    <xsl:apply-templates/>

因此，如果输入是

    <h2> Hello <em> there </em> </h2>

那么在H2的模板中的<xsl:apply-templates/>就会触发用来翻译<em>标签的模板。

翻译H2标签的输出是：

    <fo:block start-indent="10mm" ...

        original H2 tag content

    </fo:block>

我们调用Xalan来应用xhtml2fo.xsl。在调用Xalan之前，用Unix脚本xalan.sh来设置它需要用到的CLASSPATH变量。

#/bin/sh

export CLASSPATH='.;./lib/xalan.jar;./lib/xercesImpl.jar;./lib/xml-apis.jar;lib/serializer.jar'

java -classpath $CLASSPATH org.apache.xalan.xslt.Process -IN $1 -XSL xhtml2fo.xsl -OUT $2 -tt

因为Xalan需要一个XML解析器，所以这里还需要Apache Xerces和xml-api JARs。所有的jar文件都可以在Xalan的发布包中找到。

要通过对XHTML应用样式表来新建一个XSL-FO文件，可以调用脚本：

    xalan.sh  hello.xml hello.fo

我喜欢用Xalan的跟踪开关(-tt)来显示应用的模板。hello.fo文件如下：

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

<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format"

    xmlns:html="http://www.w3.org/1999/xhtml"

    writing-mode="lr-tb"

    hyphenate="false"

    text-align="start"

    role="html:html">

  <fo:layout-master-set>

    <fo:simple-page-master page-width="auto" page-height="auto"

                           master-name="all-pages">

      <fo:region-body column-gap="12pt" column-count="1" margin-left="1in"

                      margin-bottom="1in" margin-right="1in" margin-top="1in"/>

      <fo:region-before display-align="before" extent="1in"

                        region-name="page-header"/>

      <fo:region-after display-align="after" extent="1in"

                      region-name="page-footer"/>

      <fo:region-start extent="1in"/>

      <fo:region-end extent="1in"/>

    </fo:simple-page-master>

  </fo:layout-master-set>

  <fo:page-sequence master-reference="all-pages">

    <fo:title>Hello World

    <fo:static-content flow-name="page-header">

      <fo:block font-size="small" text-align="center" space-before="0.5in"

                space-before.conditionality=;"retain">

        Hello World

      </fo:block>

    </fo:static-content>

    <fo:static-content flow-name="page-footer">

      <fo:block font-size="small" text-align="center" space-after="0.5in"

                space-after.conditionality=quot;retain">

        - <fo:page-number/> -

      </fo:block>

    </fo:static-content>

    <fo:flow flow-name="xsl-region-body">

      <fo:block role="html:body">

        <fo:block space-before="1em" space-after="1em" role="html:p">

          Hello World!

        </fo:block>

      </fo:block>

    </fo:flow>

  </fo:page-sequence>

</fo:root>

第三步：XSL-FO到PDF

第三步，也就是最后一步，就是把XSL-FO文档传递给格式化程序来生成PDF。我用的是Apache FOP(Formatting Objects Processor)。FOP部分实现了XSL-FO标准，并对PDF的输出格式提供了最好的支持。而对Postscript还处于初级阶段，对微软的RTF的支持还在计划中。FOP发布版包含shell脚本fop.sh/fop.bat，它们需要传入XSL-FO文件作为输入参数来生成目标PDF文件。

在Unix下可以这样运行：

    fop.sh hello.fo hello.pdf

唯一所需的前提条件就是把设置为这个脚本使用到的FOP目录设置环境变量。

文件hello.pdf即为FOP的输出，你在本文的源代码中可以找到。

因为FOP目前并未完全实现XSL-FO标准，所以有一定的局限性。具体它实现了标准的哪些子集，可以在FOP的网站上的Compliance部分找到详细说明。

---------------------------------------------------------------------------

[译注1] 此处原文是“在XML文件中的那个</p>是JTidy自动添加的”。我使用JTidy转换的结果是</title>也被添加，而且这符合JTidy的逻辑，因此这里稍作了修改。

[译注2] 这一部分我在试着做的时候遇到很多问题。首先，有些地方作者描述的并不清楚，特别是对于模板的解释那一部分。其次，在用Xalan做转换时遇到了Connection time out的异常。这可能是由于xml文件中的dtd(xhtml1-strict.dtd)无法连接造成的。把该dtd下载到本地后，该异常即可消除。然后是无法找ent文件。所需要的这些ent都可以在xmlbuddy的安装包里找到，拷过来就可以了。我不知道作者是不是没有遇到过这些问题，也可能我这只是特例。