为oracle客户端添加连接到服务器端的方法

posted @ 2008-04-08 13:09 鲁胜迪 阅读(578) | 评论 (0) | 编辑 收藏

使用lucene对搜索结果排序

lucene默认根据匹配度对搜索结果降序排,如果对某个域进行排序?
通常分两步:

 step1)建索引时
doc.add(new Field("audittime", row.get("audittime").toString(),
                Field.Store.NO, Field.Index.UN_TOKENIZED));

关键点是你需要排序的字段建索引时应该采用Field.Index.UN_TOKENIZED,至于需不需要Field.Store.NO看实际情况,反正不影响排序

step2)搜索时
public Hits search(SearchVO searchVO) throws IOException {
        ................

        Sort sort = this.buildSort(searchVO);

        Hits hits = searcher.search(query, sort);

        return hits;
}

private Sort buildSort(SearchVO searchVO) {

        if (searchVO.getOrderby() == null || searchVO.getOrderby().length() < 1) {
            return null;
        }

        Sort sort = new Sort(searchVO.getOrderby(),
                (searchVO.getAscflag() == 1 ? false : true));

        return sort;

}

 关键点是通过建立一个Sort实例然后传给IndexSearcher 的另一个重载方法search(Query query,Sort sort);

通过Sort你可以指定排序字段名,升序降序.

如果你需要特指字段类型,你需要使用  new Sort(SortField field)
或者你需要通过多字段排序,你需要使用  new Sort(SortField[] fields)
我就不再赘述了

题外话:
   
使用lucene 排序是很简单的,但如何发挥它的效果是一个值得思考的地方.
   
如果你是实时的更新lucene索引我没话说(这需要相当谨慎的设计).

如果你定时更新索引,就会有些问题,比如你要排序的字段更新速度很快,你应该如何显示它? 因为你排序的数据(即建索引时的数据)和当前的数据并不完全同步,这会给显示带来问题.如果你显示建索引时的数据,这样排序本身没问题,但客户会很奇怪我的数据明明是6了怎么还显示4.如果你显示当前的数据就更奇怪了,客户可能会奇怪我的数据是1000怎么排名第4,排名第一的才500?  如果你的数据更新缓慢,这样做不会有什么问题.但更新很快的话就是灾难了.

posted @ 2008-04-01 10:22 鲁胜迪 阅读(7678) | 评论 (1) | 编辑 收藏

深入 Lucene 索引机制

Lucene 是一个基于 Java 的全文检索工具包，你可以利用它来为你的应用程序加入索引和检索功能。Lucene 目前是著名的 Apache Jakarta 家族中的一个开源项目，下面我们即将学习 Lucene 的索引机制以及它的索引文件的结构。

在这篇文章中，我们首先演示如何使用 Lucene 来索引文档，接着讨论如何提高索引的性能。最后我们来分析 Lucene 的索引文件结构。需要记住的是，Lucene 不是一个完整的应用程序，而是一个信息检索包，它方便你为你的应用程序添加索引和搜索功能。

架构概览

图一显示了 Lucene 的索引机制的架构。Lucene 使用各种解析器对各种不同类型的文档进行解析。比如对于 HTML 文档，HTML 解析器会做一些预处理的工作，比如过滤文档中的 HTML 标签等等。HTML 解析器的输出的是文本内容，接着 Lucene 的分词器(Analyzer)从文本内容中提取出索引项以及相关信息，比如索引项的出现频率。接着 Lucene 的分词器把这些信息写到索引文件中。

用Lucene索引文档

      接下来我将一步一步的来演示如何利用 Lucene 为你的文档创建索引。只要你能将要索引的文件转化成文本格式，Lucene 就能为你的文档建立索引。比如，如果你想为 HTML 文档或者 PDF 文档建立索引，那么首先你就需要从这些文档中提取出文本信息，然后把文本信息交给 Lucene 建立索引。我们接下来的例子用来演示如何利用 Lucene 为后缀名为 txt 的文件建立索引。

1． 准备文本文件

首先把一些以 txt 为后缀名的文本文件放到一个目录中，比如在 Windows 平台上，你可以放到 C:\\files_to_index 下面。

2． 创建索引

清单1是为我们所准备的文档创建索引的代码。

package lucene.index;
            import java.io.File;
            import java.io.FileReader;
            import java.io.Reader;
            import java.util.Date;
            import org.apache.lucene.analysis.Analyzer;
            import org.apache.lucene.analysis.standard.StandardAnalyzer;
            import org.apache.lucene.document.Document;
            import org.apache.lucene.document.Field;
            import org.apache.lucene.index.IndexWriter;
            /**
            * This class demonstrates the process of creating an index with Lucene
            * for text files in a directory.
            */
            public class TextFileIndexer {
            public static void main(String[] args) throws Exception{
            //fileDir is the directory that contains the text files to be indexed
            File   fileDir  = new File("C:\\files_to_index ");
            //indexDir is the directory that hosts Lucene's index files
            File   indexDir = new File("C:\\luceneIndex");
            Analyzer luceneAnalyzer = new StandardAnalyzer();
            IndexWriter indexWriter = new IndexWriter(indexDir,luceneAnalyzer,true);
            File[] textFiles  = fileDir.listFiles();
            long startTime = new Date().getTime();
            //Add documents to the index
            for(int i = 0; i < textFiles.length; i++){
            if(textFiles[i].isFile() && textFiles[i].getName().endsWith(".txt")){
            System.out.println("File " + textFiles[i].getCanonicalPath()
            + " is being indexed");
            Reader textReader = new FileReader(textFiles[i]);
            Document document = new Document();
            document.add(Field.Text("content",textReader));
            document.add(Field.Text("path",textFiles[i].getPath()));
            indexWriter.addDocument(document);
            }
            }
            indexWriter.optimize();
            indexWriter.close();
            long endTime = new Date().getTime();
            System.out.println("It took " + (endTime - startTime)
            + " milliseconds to create an index for the files in the directory "
            + fileDir.getPath());
            }
            }
            

正如清单1所示，你可以利用 Lucene 非常方便的为文档创建索引。接下来我们分析一下清单1中的比较关键的代码，我们先从下面的一条语句开始看起。

Analyzer luceneAnalyzer = new StandardAnalyzer();
            

这条语句创建了类 StandardAnalyzer 的一个实例，这个类是用来从文本中提取出索引项的。它只是抽象类 Analyzer 的其中一个实现。Analyzer 也有一些其它的子类，比如 SimpleAnalyzer 等。

我们接着看另外一条语句：

IndexWriter indexWriter = new IndexWriter(indexDir,luceneAnalyzer,true);
            

       这条语句创建了类 IndexWriter 的一个实例，该类也是 Lucene 索引机制里面的一个关键类。这个类能创建一个新的索引或者打开一个已存在的索引并为该索引添加文档。我们注意到该类的构造函数接受三个参数，第一个参数指定了存储索引文件的路径。第二个参数指定了在索引过程中使用什么样的分词器。最后一个参数是个布尔变量，如果值为真，那么就表示要创建一个新的索引，如果值为假，就表示打开一个已经存在的索引。

接下来的代码演示了如何添加一个文档到索引文件中。

Document document = new Document();
            document.add(Field.Text("content",textReader));
            document.add(Field.Text("path",textFiles[i].getPath()));
            indexWriter.addDocument(document);
            

      首先第一行创建了类 Document 的一个实例，它由一个或者多个的域(Field)组成。你可以把这个类想象成代表了一个实际的文档，比如一个 HTML 页面，一个 PDF 文档，或者一个文本文件。而类 Document 中的域一般就是实际文档的一些属性。比如对于一个 HTML 页面，它的域可能包括标题，内容，URL 等。我们可以用不同类型的 Field 来控制文档的哪些内容应该索引，哪些内容应该存储。如果想获取更多的关于 Lucene 的域的信息，可以参考 Lucene 的帮助文档。代码的第二行和第三行为文档添加了两个域，每个域包含两个属性，分别是域的名字和域的内容。在我们的例子中两个域的名字分别是 "content"和"path"。分别存储了我们需要索引的文本文件的内容和路径。最后一行把准备好的文档添加到了索引当中。

当我们把文档添加到索引中后，不要忘记关闭索引，这样才保证 Lucene 把添加的文档写回到硬盘上。下面的一句代码演示了如何关闭索引。

indexWriter.close();
            

利用清单1中的代码，你就可以成功的将文本文档添加到索引中去。接下来我们看看对索引进行的另外一种重要的操作，从索引中删除文档。

从索引中删除文档

类IndexReader负责从一个已经存在的索引中删除文档，如清单2所示。

File   indexDir = new File("C:\\luceneIndex");
            IndexReader ir = IndexReader.open(indexDir);
            ir.delete(1);
            ir.delete(new Term("path","C:\\file_to_index\lucene.txt"));
            ir.close();
            

       在清单2中，第二行用静态方法 IndexReader.open(indexDir) 初始化了类 IndexReader 的一个实例，这个方法的参数指定了索引的存储路径。类 IndexReader 提供了两种方法去删除一个文档，如程序中的第三行和第四行所示。第三行利用文档的编号来删除文档。每个文档都有一个系统自动生成的编号。第四行删除了路径为"C:\\file_to_index\lucene.txt"的文档。你可以通过指定文件路径来方便的删除一个文档。值得注意的是虽然利用上述代码删除文档使得该文档不能被检索到，但是并没有物理上删除该文档。Lucene 只是通过一个后缀名为 .delete 的文件来标记哪些文档已经被删除。既然没有物理上删除，我们可以方便的把这些标记为删除的文档恢复过来，如清单 3 所示，首先打开一个索引，然后调用方法 ir.undeleteAll() 来完成恢复工作。

File   indexDir = new File("C:\\luceneIndex");
            IndexReader ir = IndexReader.open(indexDir);
            ir.undeleteAll();
            ir.close();
            

你现在也许想知道如何物理上删除索引中的文档，方法也非常简单。清单 4 演示了这个过程。

File   indexDir = new File("C:\\luceneIndex");
            Analyzer luceneAnalyzer = new StandardAnalyzer();
            IndexWriter indexWriter = new IndexWriter(indexDir,luceneAnalyzer,false);
            indexWriter.optimize();
            indexWriter.close();
            

在清单 4 中，第三行创建了类 IndexWriter 的一个实例，并且打开了一个已经存在的索引。第 4 行对索引进行清理，清理过程中将把所有标记为删除的文档物理删除。

Lucene 没有直接提供方法对文档进行更新，如果你需要更新一个文档，那么你首先需要把这个文档从索引中删除，然后把新版本的文档加入到索引中去。

提高索引性能

      利用 Lucene，在创建索引的工程中你可以充分利用机器的硬件资源来提高索引的效率。当你需要索引大量的文件时，你会注意到索引过程的瓶颈是在往磁盘上写索引文件的过程中。为了解决这个问题, Lucene 在内存中持有一块缓冲区。但我们如何控制 Lucene 的缓冲区呢？幸运的是，Lucene 的类 IndexWriter 提供了三个参数用来调整缓冲区的大小以及往磁盘上写索引文件的频率。

1．合并因子（mergeFactor）

这个参数决定了在 Lucene 的一个索引块中可以存放多少文档以及把磁盘上的索引块合并成一个大的索引块的频率。比如，如果合并因子的值是 10，那么当内存中的文档数达到 10 的时候所有的文档都必须写到磁盘上的一个新的索引块中。并且，如果磁盘上的索引块的隔数达到 10 的话，这 10 个索引块会被合并成一个新的索引块。这个参数的默认值是 10，如果需要索引的文档数非常多的话这个值将是非常不合适的。对批处理的索引来讲，为这个参数赋一个比较大的值会得到比较好的索引效果。

2．最小合并文档数

这个参数也会影响索引的性能。它决定了内存中的文档数至少达到多少才能将它们写回磁盘。这个参数的默认值是10，如果你有足够的内存，那么将这个值尽量设的比较大一些将会显著的提高索引性能。

3．最大合并文档数

这个参数决定了一个索引块中的最大的文档数。它的默认值是 Integer.MAX_VALUE，将这个参数设置为比较大的值可以提高索引效率和检索速度，由于该参数的默认值是整型的最大值，所以我们一般不需要改动这个参数。

清单 5 列出了这个三个参数用法，清单 5 和清单 1 非常相似，除了清单 5 中会设置刚才提到的三个参数。

/**
            * This class demonstrates how to improve the indexing performance
            * by adjusting the parameters provided by IndexWriter.
            */
            public class AdvancedTextFileIndexer  {
            public static void main(String[] args) throws Exception{
            //fileDir is the directory that contains the text files to be indexed
            File   fileDir  = new File("C:\\files_to_index");
            //indexDir is the directory that hosts Lucene's index files
            File   indexDir = new File("C:\\luceneIndex");
            Analyzer luceneAnalyzer = new StandardAnalyzer();
            File[] textFiles  = fileDir.listFiles();
            long startTime = new Date().getTime();
            int mergeFactor = 10;
            int minMergeDocs = 10;
            int maxMergeDocs = Integer.MAX_VALUE;
            IndexWriter indexWriter = new IndexWriter(indexDir,luceneAnalyzer,true);
            indexWriter.mergeFactor = mergeFactor;
            indexWriter.minMergeDocs = minMergeDocs;
            indexWriter.maxMergeDocs = maxMergeDocs;
            //Add documents to the index
            for(int i = 0; i < textFiles.length; i++){
            if(textFiles[i].isFile() && textFiles[i].getName().endsWith(".txt")){
            Reader textReader = new FileReader(textFiles[i]);
            Document document = new Document();
            document.add(Field.Text("content",textReader));
            document.add(Field.Keyword("path",textFiles[i].getPath()));
            indexWriter.addDocument(document);
            }
            }
            indexWriter.optimize();
            indexWriter.close();
            long endTime = new Date().getTime();
            System.out.println("MergeFactor: " + indexWriter.mergeFactor);
            System.out.println("MinMergeDocs: " + indexWriter.minMergeDocs);
            System.out.println("MaxMergeDocs: " + indexWriter.maxMergeDocs);
            System.out.println("Document number: " + textFiles.length);
            System.out.println("Time consumed: " + (endTime - startTime) + " milliseconds");
            }
            }
            

通过这个例子，我们注意到在调整缓冲区的大小以及写磁盘的频率上面 Lucene 给我们提供了非常大的灵活性。现在我们来看一下代码中的关键语句。如下的代码首先创建了类 IndexWriter 的一个实例，然后对它的三个参数进行赋值。

int mergeFactor = 10;
            int minMergeDocs = 10;
            int maxMergeDocs = Integer.MAX_VALUE;
            IndexWriter indexWriter = new IndexWriter(indexDir,luceneAnalyzer,true);
            indexWriter.mergeFactor = mergeFactor;
            indexWriter.minMergeDocs = minMergeDocs;
            indexWriter.maxMergeDocs = maxMergeDocs;
            

下面我们来看一下这三个参数取不同的值对索引时间的影响，注意参数值的不同和索引之间的关系。我们为这个实验准备了 10000 个测试文档。表 1 显示了测试结果。

        通过表 1，你可以清楚地看到三个参数对索引时间的影响。在实践中，你会经常的改变合并因子和最小合并文档数的值来提高索引性能。只要你有足够大的内存，你可以为合并因子和最小合并文档数这两个参数赋尽量大的值以提高索引效率，另外我们一般无需更改最大合并文档数这个参数的值，因为系统已经默认将它设置成了最大。

Lucene 索引文件结构分析

        在分析 Lucene 的索引文件结构之前，我们先要理解反向索引（Inverted index）这个概念，反向索引是一种以索引项为中心来组织文档的方式，每个索引项指向一个文档序列，这个序列中的文档都包含该索引项。相反，在正向索引中，文档占据了中心的位置，每个文档指向了一个它所包含的索引项的序列。你可以利用反向索引轻松的找到那些文档包含了特定的索引项。Lucene正是使用了反向索引作为其基本的索引结构。

索引文件的逻辑视图

在Lucene 中有索引块的概念，每个索引块包含了一定数目的文档。我们能够对单独的索引块进行检索。图 2 显示了 Lucene 索引结构的逻辑视图。索引块的个数由索引的文档的总数以及每个索引块所能包含的最大文档数来决定。

Lucene 中的关键索引文件

下面的部分将会分析Lucene中的主要的索引文件，可能分析有些索引文件的时候没有包含文件的所有的字段，但不会影响到对索引文件的理解。

1．索引块文件

这个文件包含了索引中的索引块信息，这个文件包含了每个索引块的名字以及大小等信息。表 2 显示了这个文件的结构信息。

2．域信息文件

我们知道，索引中的文档由一个或者多个域组成，这个文件包含了每个索引块中的域的信息。表 3 显示了这个文件的结构。

3．索引项信息文件

这是索引文件里面最核心的一个文件，它存储了所有的索引项的值以及相关信息，并且以索引项来排序。表 4 显示了这个文件的结构。

4．频率文件

这个文件包含了包含索引项的文档的列表，以及索引项在每个文档中出现的频率信息。如果Lucene在索引项信息文件中发现有索引项和搜索词相匹配。那么 Lucene 就会在频率文件中找有哪些文件包含了该索引项。表5显示了这个文件的一个大致的结构，并没有包含这个文件的所有字段。

5．位置文件

这个文件包含了索引项在每个文档中出现的位置信息，你可以利用这些信息来参与对索引结果的排序。表 6 显示了这个文件的结构

到目前为止我们介绍了 Lucene 中的主要的索引文件结构，希望能对你理解 Lucene 的物理的存储结构有所帮助。

总结

目前已经有非常多的知名的组织正在使用 Lucene，比如，Lucene 为 Eclipse 的帮助系统，麻省理工学院的 OpenCourseWare 提供了搜索功能。通过阅读这篇文章，希望你能对 Lucene 的索引机制有所了解，并且你会发现利用 Lucene 创建索引是非常简单的事情。

转载于http://www.128kj.com/article/article5/lucene4.html

posted @ 2008-03-31 20:39 鲁胜迪 阅读(283) | 评论 (0) | 编辑 收藏

Lucene开发环境配置及Demo调试

posted @ 2008-03-26 13:34 鲁胜迪 阅读(5717) | 评论 (4) | 编辑 收藏

eclipse技巧篇

posted @ 2008-03-26 09:11 鲁胜迪 阅读(356) | 评论 (0) | 编辑 收藏

在Eclipse中初用lucene

lucene是apache的一个开源项目，一个开放源代码的全文检索引擎工具包。今天初学了一下。

1. 首先下载最新版的lucene

    http://apache.mirror.phpchina.com/lucene/java/lucene-2.2.0.zip

2. 解压下载的包，会看到两个jar文件。打开eclipse,新建个工程，在该工程处点右键，选择properties，在 Libraries项中导入那两个jar文件。

3. 找到IndexFiles.class,双击打开，如图:

    再点击菜单栏上的run，选择open run dialog， 在arguments项填入 lucene解压的目录/src

    运行，就可以看到一些搜索结果了

4. 再选择SearchFiles.class,运行，有可能需要open run dialog中改一下设置，然后程序会让我们输入搜索词，输入即可。

今天仅仅初步了解了一下lucene，最近一直都会跟进，感觉lucene还是比较有意思的，也比较实用。

转载于http://hi.baidu.com/homefovever/blog/item/94121e3da42396ed3c6d97c5.html

posted @ 2008-03-25 12:24 鲁胜迪 阅读(3864) | 评论 (0) | 编辑 收藏

Lucene 安装

1.在网上下载了lucene 2.2版，http://jakarta.apache.org/Lucene/ 

2.然后分别安装了jdk1.6和tomcat5.5

3.建一个目录d:\lucenetest\index，在里面放一些文本文件和网页文件

4.进入dos模式，输入命令：java org.apache.lucene.demo.IndexFiles d:\lucenetest\index

如：c:\>java org.apache.lucene.demo.IndexFiles d:\lucenetest\index 按回车，

  这时会索引d:\lucenetest\index目录下的所有文件，包括子目录中的文件，并将索引文件写入：c:\index目录中

（自动创建的,根据你的dos符起始路径，将在其下建index目录）。

  输入命令：java org.apache.lucene.demo.SearchFiles

如：c:\>java org.apache.lucene.demo.SearchFiles 回车



5. Query:在这里输入检索内容

 环境变量还是附上
 CLASSPATH ：.;%JAVA_HOME%\lib\tools.jar;%JAVA_HOME%\lib\lucene-core-2.0.0.jar;%JAVA_HOME%\lib\lucene-demos-2.0.0.jar
  JAVA_HOME C:\Program Files\Java\jdk1.6
  path 加上 %JAVA_HOME%\bin
6.lucene 安装中可能会出现很多问题，与你jdk 1.6的安装和TOMCAT的安装有一定的关系。

http://searcher.org.cn/html/lucene/20070921/212.html

posted @ 2008-03-24 10:31 鲁胜迪 阅读(1218) | 评论 (0) | 编辑 收藏

Ghost各版本对比

posted @ 2008-03-18 15:48 鲁胜迪 阅读(1402) | 评论 (0) | 编辑 收藏

Lucene配置

Lucene开发环境配置；Lucene开发包中Demo调试。

一、Lucene开发环境配置

step1.Lucene开发包下载

下载地址1：http://mirror.vmmatrix.net/apache/lucene/java/

下载地址2：http://apache.justdn.org/lucene/java/

从中选择合适的版本，本文使用lucene-1.9.1.zip。

step2.Java开发环境配置（略）

本文使用jdk1.5.0_06，安装目录为：C:\Java\jdk1.5.0_06。

step3.Tomcat安装（略）

本文使用Tomcat 5.0，安装目录为：C:\Java\Tomcat 5.0。

step4.Lucene开发环境配置

1）解压下载的lucene-1.9.1.zip，可以看到lucene-core-1.9.1.jar和lucene-demos-1.9.1.jar这两个文件。本文解压目录为：C:\Java\lucene-1.9.1。

2）将lucene-core-1.9.1.jar和lucene-demos-1.9.1.jar文件所在路径添加到classpath。

本文将C:\Java\lucene-1.9.1\lucene-core-1.9.1.jar;C:\Java\lucene-1.9.1\lucene-demos-1.9.1.jar添加到classpath中。

二、Lucene开发包中Demo调试

控制台应用程序

step1.建立索引

>java org.apache.lucene.demo.IndexFiles C:\Java\lucene-1.9.1\src

将对C:\Java\lucene-1.9.1\src下所有文件建立索引，同时，在当前命令行位置将生成“index”文件夹。

step2.执行查询

>java org.apache.lucene.demo.SearchFiles

将会出现“Query:”提示符，在其后输入关键字，回车，即可得到查询结果。

 Web应用程序

step1.将lucene-core-1.9.1.jar和lucene-demos-1.9.1.jar这两个文件复制到C:\Java\Tomcat 5.0\common\lib

step2.解压下载的lucene-1.9.1.zip，可以看到luceneweb.war文件。将该文件复制到C:\Java\Tomcat 5.0\webapps

step3.重启Tomcat服务器。

step4.建立索引

>java org.apache.lucene.demo.IndexHTML -create -index D:\opt\lucene\index  ..

step5.执行查询

http://localhost:8080/luceneweb

在文本框中输入关键字，执行，即可得到查询结果。

参考资料：http://lucene.apache.org/java/docs/gettingstarted.html

posted @ 2008-03-15 12:41 鲁胜迪 阅读(2105) | 评论 (0) | 编辑 收藏

JDom使用详解

JDom是不错的API，算得上简单高效，最重要是已经成为jcp的一部分，这个咱得弄弄。不过www.jdom.org上写文档的人实在太懒，文档出奇的少，流传得最广的恐怕是IBM上面的一篇《JDom让java XML变得容易》，不过这篇文章只涉及基本的读写操作，远不能胜任实际工作。花了两天时间，把JDom的基本操作整理出来了，涵盖了大部分的操作：元素、属性、命名空间、PI、DTD、Schema，应付一般的应用没什么问题。反正我没有在网上见到更加详尽的版本，你见过的话，请留下连接。暂时来不及编写详细的说明，先帖几段程序，对有经验的Java开发者来说，已经足够了。程序都已经经过了实际的测试，我使用的JDom是0.9版。

1、创建XML文档：


package org.bromon.jdom.example; 
import java.io.*; 
import org.jdom.*; 
import org.jdom.input.*; 
import org.jdom.output.*; 

public class CreateXML 
{ 
public void Create() 
{ 
try 
{ 
Document doc = new Document(); 
ProcessingInstruction pi=new ProcessingInstruction("xml-stylesheet","type="textxsl" href="test.xsl""); 
doc.addContent(pi); 

Namespace ns = Namespace.getNamespace("http://www.bromon.org" ); 
Namespace ns2 = Namespace.getNamespace("other", "http://www.w3c.org" ); 

Element root = new Element("根元素", ns); 
root.addNamespaceDeclaration(ns2); 
doc.setRootElement(root); 
Element el1 = new Element("元素一"); 
el1.setAttribute("属性", "属性一"); 

Text text1=new Text("元素值"); 
Element em = new Element("元素二").addContent("第二个元素"); 

el1.addContent(text1); 
el1.addContent(em); 

Element el2 = new Element("元素三").addContent("第三个元素"); 

root.addContent(el1); 
root.addContent(el2); 

//缩进四个空格,自动换行,gb2312编码 
XMLOutputter outputter = new XMLOutputter(" ", true,"GB2312"); 
outputter.output(doc, new FileWriter("test.xml")); 
}catch(Exception e) 
{ 
System.out.println(e); 
} 
} 

public static void main(String args[]) 
{ 
new CreateXML().Create(); 
} 

} 

2、DTD验证的：


package org.bromon.jdom.example; 
import java.io.*; 
import org.jdom.*; 
import org.jdom.input.*; 
import org.jdom.output.*; 

public class XMLWithDTD 
{ 
public void validate() 
{ 
try 
{ 
SAXBuilder builder = new SAXBuilder(true); 
builder.setFeature("http://xml.org/sax/features/validation";,true); 
Document doc = builder.build(new FileReader("author.xml")); 

System.out.println("搞掂"); 
XMLOutputter outputter = new XMLOutputter(); 
outputter.output(doc, System.out); 
}catch(Exception e) 
{ 
System.out.println(e); 
} 

} 
public static void main(String args[]) 
{ 
new XMLWithDTD().validate(); 
} 

} 

需要说明的是，这个程序没有指明使用哪个DTD文件。DTD文件的位置是在XML中指定的，而且DTD不支持命名空间，一个XML只能引用一个DTD，所以程序直接读取XML中指定的DTD，程序本身不用指定。不过这样一来，好象就只能使用外部式的DTD引用方式了？高人指点。

3、XML Schema验证的：


package org.bromon.jdom.example; 
import java.io.*; 
import org.jdom.*; 
import org.jdom.input.*; 
import org.jdom.output.*; 

public class XMLWithSchema 
{ 
String xml="test.xml"; 
String schema="test-schema.xml"; 
public void validate() 
{ 
try 
{ 
SAXBuilder builder = new SAXBuilder(true); 
//指定约束方式为XML schema 
builder.setFeature("http://apache.org/xml/features/validation/schema";, true); 
//导入schema文件 
builder.setProperty("http://apache.org/xml/properties/schema/external-noNamespaceSchemaLocation";,schema); 
Document doc = builder.build(new FileReader(xml)); 

System.out.println("搞掂"); 
XMLOutputter outputter = new XMLOutputter(); 
outputter.output(doc, System.out); 
}catch(Exception e) 
{ 
System.out.println("验证失败:"+e); 
} 

} 

}

posted @ 2008-03-04 10:04 鲁胜迪 阅读(721) | 评论 (0) | 编辑 收藏