< action
 path = "/HelloWorld"
 type ="hello.HelloAction"
 name = "HelloForm"
 scope = "request"
 validate = "true"
 input = "/hello.jsp"
>
< forward name="SayHello" path="/hello.jsp" />
</action >

某些网站允许软件开发社团通过发布开发者指南、白皮书、FAQs【常见问题解答】和源代码以实现信息的共享。随着信息量的增长，和几个开发者贡献出自己的知识库，于是网站提供搜索引擎来搜索站点上现有的所有信息。虽然这些搜索引擎对文本文件的搜索可以做的很好，但对开发者搜索源代码做了比较严格的限制。搜索引擎认为源代码就是纯文本文件，因此，在这一点上，与成熟的可以处理大量源文件的工具――grep相比没有什么不同。

在这篇文章中，我推荐使用Lucene，它是基于Java的开源搜索引擎，通过提取和索引相关的源码元素来搜索源代码。这里，我仅限定搜索Java源代码。然而，Lucene同样可以做到对其他编程语言的源代码的搜索。

文章给出了在Lucene环境下搜索引擎重点方面的简短概述。要了解更多细节信息，参考Resources部分。

版权声明：任何获得Matrix授权的网站，转载时请务必保留以下作者信息和链接
作者:Renuka;Knightchen(作者的blog:http://blog.matrix.org.cn/page/Knightchen)
原文:http://www.matrix.org.cn/resource/article/44/44362_Lucene+Java.html
关键字:Lucene;Java

概述
Lucene是最流行的开源搜索引擎库之一。它由能文本索引和搜索的核心API组成。Lucene能够对给出一组文本文件创建索引并且允许你用复杂的查询来搜索这些索引，例如：+title:Lucene -content:Search、search AND Lucene、+search +code。在进入搜索细节之前，先让我来介绍一下Lucene的一些功能。

在Lucene中索引文本

搜索引擎对所有需要被搜索的数据进行扫描并将其存储到能有效获取的一个结构里。这个最有名的结构被称为倒排索引。例如，现在考虑对一组会议记录进行索引。首先，每个会议记录的文件被分为几个独立的部分或者域：如标题、作者、email、摘要和内容。其次，每一域的内容被标记化并且提取出关键字或者术语。这样就可以建立如下表所示会议记录的倒排索引。

        ....                 

对于域中的每一术语而言，上图存储了两方面的内容：该术语在文件中出现的数量（即频率【DF】）以及包含该术语的每一文件的ID。对于每个术语保存的其它细节：例如术语在每个文件中出现的次数以及出现的位置也被保存起来。无论如何，对于我们非常重要的一点是要知道：利用Lucene检索文件意味着将其保存为一种特定格式，该格式允许高效率查询及获取。

分析被索引的文本

Lucene使用分析器来处理被索引的文本。在将其存入索引之前，分析器用于将文本标记化、摘录有关的单词、丢弃共有的单词、处理派生词（把派生词还原到词根形式，意思是把bowling、bowler和bowls还原为bowl）和完成其它要做的处理。Lucene提供的通用分析器是：
        SimpleAnalyzer：用字符串标记一组单词并且转化为小写字母。
        StandardAnalyzer：用字符串标记一组单词，可识别缩写词、email地址、主机名称等等。并丢弃基于英语的stop words (a, an, the, to)等、处理派生词。

检索（搜索索引）
索引结构建立后，可以通过指定被搜索的字段和术语构造复杂的查询来对索引进行检索。例如，用户查询abstract：system AND email:abc@mit.edu得到的结果是所有在摘要中包含system、在email地址中有abc@mit.edu的文件。也就是说，如果在前面倒排索引表的基础上搜索就返回Doc15。与查询匹配的文件是按照术语在文件中出现的次数以及包含该术语的文档的数量进行排列的。Lucene执行一种顺序排列机制并且提供了给我们更改它的弹性。

源代码搜索引擎

现在我们知道了关于搜索引擎的基本要点，下面让我们看一看用于搜索源代码的搜索引擎应如何实现。下文中展示在搜索Java示例代码时，开发者主要关注以下Java类：
继承一个具体类或实现一个接口。
调用特定的方法。
使用特定的Java类。

综合使用上述部分的组合可以满足开发者获取他们正在寻找相关代码的需要。因此搜索引擎应该允许开发者对这些方面进行单个或组合查询。IDEs【集成开发环境】有另一个局限性：大部分可使用的工具仅仅基于上述标准之一来支持搜索源代码。在搜索中，缺乏组合这些标准进行查询的灵活性。

现在我们开始建立一个支持这些要求的源代码搜索引擎。

编写源代码分析器
第一步先写一个分析器，用来提取或去除源代码元素，确保建立最佳的索引并且仅包含相关方面的代码。在Java语言中的关键字--public,null,for,if等等，在每个.java文件中它们都出现了，这些关键字类似于英语中的普通单词（the,a,an,of）。因而，分析器必须把这些关键字从索引中去掉。

我们通过继承Lucene的抽象类Analyzer来建立一个Java源代码分析器。下面列出了JavaSourceCodeAnalyzer类的源代码，它实现了tokenStream（String，Reader）方法。这个类定义了一组【stop words】，它们能够在索引过程中，使用Lucene提供的StopFilter类来被去除。tokenStream方法用于检查被索引的字段。如果该字段是“comment”，首先要利用LowerCaseTokenizer类将输入项标记化并转换成小写字母，然后利用StopFilter类除去英语中的【stop words】（有限的一组英语【stop words】），再利用PorterStemFilter移除通用的语形学以及词尾后缀。如果被索引的内容不是“comment”，那么分析器就利用LowerCaseTokenizer类将输入项标记化并转换成小写字母，并且利用StopFilter类除去Java关键字。

package com.infosys.lucene.code JavaSourceCodeAnalyzer.;

import java.io.Reader;
import java.util.Set;
import org.apache.lucene.analysis.*;

public class JavaSourceCodeAnalyzer extends Analyzer {
      private Set javaStopSet;
      private Set englishStopSet;
      private static final String[] JAVA_STOP_WORDS = {
         "public","private","protected","interface",
            "abstract","implements","extends","null""new",
           "switch","case", "default" ,"synchronized" ,
            "do", "if", "else", "break","continue","this",
           "assert" ,"for","instanceof", "transient",
            "final", "static" ,"void","catch","try",
            "throws","throw","class", "finally","return",
            "const" , "native", "super","while", "import",
            "package" ,"true", "false" };
     private static final String[] ENGLISH_STOP_WORDS ={
            "a", "an", "and", "are","as","at","be" "but",
            "by", "for", "if", "in", "into", "is", "it",
            "no", "not", "of", "on", "or", "s", "such",
            "that", "the", "their", "then", "there","these",
            "they", "this", "to", "was", "will", "with" };
     public SourceCodeAnalyzer(){
            super();
            javaStopSet = StopFilter.makeStopSet(JAVA_STOP_WORDS);
            englishStopSet = StopFilter.makeStopSet(ENGLISH_STOP_WORDS);
     }
     public TokenStream tokenStream(String fieldName, Reader reader) {
            if (fieldName.equals("comment"))
                     return   new PorterStemFilter(new StopFilter(
                        new LowerCaseTokenizer(reader),englishStopSet));
            else
                     return   new StopFilter(
                   new LowerCaseTokenizer(reader),javaStopSet);
     }
}

编写类JavaSourceCodeIndexer
第二步生成索引。用来建立索引的非常重要的类有IndexWriter、Analyzer、Document和Field。对每一个源代码文件建立Lucene的一个Document实例。解析源代码文件并且摘录出与代码相关的语法元素，主要包括：导入声明、类名称、所继承的类、实现的接口、实现的方法、方法使用的参数和每个方法的代码等。然后把这些句法元素添加到Document实例中每个独立的Field实例中。然后使用存储索引的IndexWriter实例将Document实例添加到索引中。

下面列出了JavaSourceCodeIndexer类的源代码。该类使用了JavaParser类解析Java文件和摘录语法元素，也可以使用Eclipse3.0 ASTParser。这里就不探究JavaParser类的细节了，因为其它解析器也可以用于提取相关源码元素。在源代码文件提取元素的过程中，创建Filed实例并添加到Document实例中。

import org.apache.lucene.document.*;
import org.apache.lucene.index.*;
import com.infosys.lucene.code.JavaParser.*;

public class JavaSourceCodeIndexer {
    private static JavaParser parser = new JavaParser();
        private static final String IMPLEMENTS = "implements";
        private static final String IMPORT = "import";
        ...
        public static void main(String[] args) {
                File indexDir = new File("C:\\Lucene\\Java");
                File dataDir = new File("C:\\JavaSourceCode ");
                IndexWriter writer = new IndexWriter(indexDir,
                    new JavaSourceCodeAnalyzer(), true);
                indexDirectory(writer, dataDir);
                writer.close();
        }
        public static void indexDirectory(IndexWriter writer, File dir){
            File[] files = dir.listFiles();
            for (int i = 0; i < files.length; i++) {
                    File f = files[i];
                // Create a Lucene Document
                Document doc = new Document();
                //  Use JavaParser to parse file
                parser.setSource(f);
                addImportDeclarations(doc, parser);
                        addComments(doc, parser);
                 // Extract Class elements Using Parser
                JClass cls = parser.getDeclaredClass();
                addClass(doc, cls);
                 // Add field to the Lucene Document
                       doc.add(Field.UnIndexed(FILENAME, f.getName()));
                writer.addDocument(doc);
                    }
        }
        private static void addClass(Document doc, JClass cls) {
                   //For each class add Class Name field
            doc.add(Field.Text(CLASS, cls.className));
            String superCls = cls.superClass;
            if (superCls != null)
                   //Add the class it extends as extends field
        doc.add(Field.Text(EXTENDS, superCls));
            // Add interfaces it implements
            ArrayList interfaces = cls.interfaces;
            for (int i = 0; i < interfaces.size(); i++)
                doc.add(Field.Text(IMPLEMENTS, (String) interfaces.get(i)));
                    //Add details  on methods declared
            addMethods(cls, doc);
            ArrayList innerCls = cls.innerClasses;
                   for (int i = 0; i < innerCls.size(); i++)
                addClass(doc, (JClass) innerCls.get(i));
         }
        private static void addMethods(JClass cls, Document doc) {
            ArrayList methods = cls.methodDeclarations;
            for (int i = 0; i < methods.size(); i++) {
                       JMethod method = (JMethod) methods.get(i);
                // Add method name field
                doc.add(Field.Text(METHOD, method.methodName));
                // Add return type field
                doc.add(Field.Text(RETURN, method.returnType));
                ArrayList params = method.parameters;
                for (int k = 0; k < params.size(); k++)
                // For each method add parameter types
                    doc.add(Field.Text(PARAMETER, (String)params.get(k)));
                String code = method.codeBlock;
                if (code != null)
                //add the method code block
                    doc.add(Field.UnStored(CODE, code));
            }
        }
        private static void addImportDeclarations(Document doc, JavaParser parser) {
                   ArrayList imports = parser.getImportDeclarations();
            if (imports == null)     return;
            for (int i = 0; i < imports.size(); i++)
                    //add import declarations as keyword
                doc.add(Field.Keyword(IMPORT, (String) imports.get(i)));
        }
}

Lucene有四种不同的字段类型：Keyword，UnIndexed，UnStored和Text，用于指定建立最佳索引。
        Keyword字段是指不需要分析器解析但需要被编入索引并保存到索引中的部分。JavaSourceCodeIndexer类使用该字段来保存导入类的声明。
        UnIndexed字段是既不被分析也不被索引，但是要被逐字逐句的将其值保存到索引中。由于我们一般要存储文件的位置但又很少用文件名作为关键字来搜索，所以用该字段来索引Java文件名。
        UnStored字段和UnIndexed字段相反。该类型的Field要被分析并编入索引，但其值不会被保存到索引中。由于存储方法的全部源代码需要大量的空间。所以用UnStored字段来存储被索引的方法源代码。可以直接从Java源文件中取出方法的源代码，这样作可以控制我们的索引的大小。
        Text字段在索引过程中是要被分析、索引并保存的。类名是作为Text字段来保存。下表展示了JavaSourceCodeIndexer类使用Field字段的一般情况。



1.
   用Lucene建立的索引可以用Luke预览和修改，Luke是用于理解索引很有用的一个开源工具。图1中是Luke工具的一张截图，它显示了JavaSourceCodeIndexer类建立的索引。


图1：在Luke中索引截图

如图所见，导入类的声明没有标记化或分析就被保存了。类名和方法名被转换为小写字母后，才保存的。

查询Java源代码
建立多字段索引后，可以使用Lucene来查询这些索引。它提供了这两个重要类分别是IndexSearcher和QueryParser，用于搜索文件。QueryParser类则用于解析由用户输入的查询表达式，同时IndexSearcher类在文件中搜索满足查询条件的结果。下列表格显示了一些可能发生的查询及它的含义：


用户通过索引不同的语法元素组成有效的查询条件并搜索代码。下面列出了用于搜索的示例代码。

public class JavaCodeSearch {
public static void main(String[] args) throws Exception{
    File indexDir = new File(args[0]);
    String q =  args[1]; //parameter:JGraph code:insert
    Directory fsDir = FSDirectory.getDirectory(indexDir,false);
    IndexSearcher is = new IndexSearcher(fsDir);

    PerFieldAnalyzerWrapper analyzer = new
        PerFieldAnalyzerWrapper( new
                JavaSourceCodeAnalyzer());

    analyzer.addAnalyzer("import", new KeywordAnalyzer());
    Query query = QueryParser.parse(q, "code", analyzer);
    long start = System.currentTimeMillis();
    Hits hits = is.search(query);
    long end = System.currentTimeMillis();
    System.err.println("Found " + hits.length() +
                " docs in " + (end-start) + " millisec");
    for(int i = 0; i < hits.length(); i++){
    Document doc = hits.doc(i);
        System.out.println(doc.get("filename")
                + " with a score of " + hits.score(i));
    }
    is.close();
}
}

IndexSearcher实例用FSDirectory来打开包含索引的目录。然后使用Analyzer实例分析搜索用的查询字符串，以确保它与索引（还原词根，转换小写字母，过滤掉，等等）具有同样的形式。为了避免在查询时将Field作为一个关键字索引，Lucene做了一些限制。Lucene用Analyzer分析在QueryParser实例里传给它的所有字段。为了解决这个问题，可以用Lucene提供的PerFieldAnalyzerWrapper类为查询中的每个字段指定必要的分析。因此，查询字符串import：org.w3c.* AND code:Document将用KeywordAnalyzer来解析字符串org.w3c.*并且用JavaSourceCodeAnalyzer来解析Document。QueryParser实例如果查询没有与之相符的字段，就使用默认的字段：code，使用PerFieldAnalyzerWrapper来分析查询字符串，并返回分析后的Query实例。IndexSearcher实例使用Query实例并返回一个Hits实例，它包含了满足查询条件的文件。

结束语

这篇文章介绍了Lucene——文本搜索引擎，其可以通过加载分析器及多字段索引来实现源代码搜索。文章只介绍了代码搜索引擎的基本功能，同时在源码检索中使用愈加完善的分析器可以提高检索性能并获得更好的查询结果。这种搜索引擎可以允许用户在软件开发社区搜索和共享源代码。

资源
这篇文章的示例Sample code
Matrix:http://www.matrix.org.cn
Onjava:http://www.onjava.com/
Lucene home page
"Introduction to Text Indexing with Apache Jakarta Lucene:" 这是篇简要介绍使用Lucene的文章。
Lucene in Action: 在使用Lucene方面进行了深入地讲解。

Renuka Sindhgatta 是一位资深的构架师，现在在印度班加罗尔市【 in the Software Engineering and Technology labs of Infosys Technologies Limited 】工作。

J2EE简介

J2EE是一个开放的、基于标准的平台，可以开发、部署和管理N层结构的、面向Web的、以服务器为中心的企业级应用，它是利用Java 2 平台来简化与多级企业解决方案的开发、部署和管理相关的诸多复杂问题的应用体系结构。

J2EE平台采用一个多层次分布式的应用模式。这意味着应用逻辑根据功能被划分成组件，组成J2EE应用的不同应用组件安装在不同的服务器上，这种划分是根据应用组件属于多层次J2EE环境中的哪一个层次来决定的。如图1所示，J2EE应用可以由三或四个层次组成，J2EE多层次应用一般被认为是三层应用，因为它们是被分布在三个不同的地点：客户端机器、J2EE服务器和数据库或后端的传统系统服务器。三层架构应用是对标准的客户端/服务器应用架构的一种扩展， 即在客户端应用和后台存储之间增加一个多线程应用服务器。

J2EE体系包括JSP、Servlet、EJB、WEB SERVICE等多项技术。这些技术的出现给电子商务时代的WEB应用开发提供了一个非常有竞争力的选择。怎样把这些技术组合起来，形成一个适应项目需要的稳定架构是项目开发过程中一个非常重要的步骤。

一个成功的软件需要有一个成功的架构，但软件架构的建立是一个复杂而又持续改进的过程，软件开发者们不可能对每个不同的项目做不同的架构，而总是尽量重用以前的架构，或开发出尽量通用的架构方案，Struts就是流行的基于J2EE的架构方案之一，其他常用的基于J2EE的架构方案还有Turbine、RealMothods等。本文主要探讨Struts框架技术的应用。

J2EE应用程序架构的发展

在J2EE应用程序架构的发展路程中，主要经历了两个大的阶段：

1、Model 1

在JSP页面中结合业务逻辑、服务器端处理程序和HTML，在JSP页面中同时实现显示、业务逻辑和流程控制，从而快速的完成Web应用开发。这种模型的不足之处：1）不利于应用扩展和更新。2）业务逻辑和表示逻辑混合在JSP页面中没有进行抽象和分离，不利于应用系统业务的重用和改动。

2、Model 2

表示的是基于MVC模式的框架。根据Model 2，servlet 处理数据存取和导航流， JSP处理表现。Model 2 使Java 工程师和HTML设计者分别工作于它们所擅长和负责的部分。Model 2应用的一部分发生改变并不强求其他部分也跟着发生改变。HTML 开发人员可以改变程序的外观和感觉，并不需要改变后端servlet的工作方式。把应用逻辑、处理过程和显示逻辑分成不同的组件实现。弥补了Model1的不足。

Struts框架技术

Struts 框架就是基于Model 2 的架构，也就是基于MVC模式的框架技术。它是一个免费的开源的WEB层的应用框架,具有很高的可配置性，和有一个不断增长的特性列表。一个前端控制组件，一系列动作类，动作映射，处理XML的实用工具类，服务器端java bean 的自动填充，支持验证的WEB 表单，国际化支持，生成HTML，实现表现逻辑和模板组成了struts的灵魂。图2显示了Struts组件是如何一起工作的。

Struts 的ActionServlet 控制导航流。其他Struts 类，比如Action, 用来访问业务逻辑类。当 ActionServlet 从容器接收到一个请求，它使用URI (或者路径“path”) 来决定哪个Action 将用来处理请求。一个 Action可以校验输入，并且访问业务层以从数据库或其他数据服务中检索信息。

为校验输入或者使用输入来更新数据库， Action 需要知道什么被提交上来。并不是强制每个Action 从请求中抓取这些值，而是由 ActionServlet 将输入绑定到JavaBean中。输入 bean是Struts ActionForm c类的子类。ActionServlet 通过查找请求的路径可以决定使用哪个ActionForm，Action 也是通过同样的方法选取的。每个Action都必须以HTTP 响应进行应答。 通常, Struts Action 并不自行加工响应信息，而是将请求转发到其他资源，比如JSP 页面。Struts 提供一个ActionForward 类，用来将一个页面的路径存储为逻辑名称。当完成业务逻辑后，Action 选择并向Servlet返回一个ActionForward。Servlet 然后使用存储在ActionForward 对象中的路径来调用页面完成响应。

Struts 将这些细节都绑定在一个ActionMapping 对象中。每个ActionMapping 相对于一个特定的路径。当某个路径被请求时，Servlet 就查询ActionMapping 对象。ActionMapping对象告诉servlet哪个Actions、 ActionForms 和 ActionForwards 将被使用。

所有这些细节，关于Action， ActionForm， ActionForward， ActionMapping，以及其他一些东西，都在struts-config.xml 文件中定义。 ActionServlet 在启动时读取这个配置文件，并创建一个配置对象数据库。在运行时，Struts 应用根据的是文件创建的配置对象，而不是文件本身。

基于Struts框架的应用设计实例

本文以“面向铸造行业的网络化制造ASP平台开发”项目中的软件租用模块为例，来说明如何设计基于Struts框架的Web应用。在该模块中，用户合法登陆网站后，可以根据需要选择所要租用的软件类型及软件中的功能模块，确认信息提交服务器后，用户将收到系统给予的登陆密码，用户即可登陆网站，在线使用租用软件，实行业务托管。

根据项目需求分析,确定该系统必须具备的性能有:1)良好的交互性:工作内容中有相当大的部分是人机交流,这就要求系统的交互性要强。2)较好的可扩展性:工作的内容和形式具有多变性,要求系统具有良好的可扩展性。3)良好的可维护性:系统投入使用后,主要是由管理员承担系统维护的工作,维护人员不定期变动,这就要求系统的可维护性强。4)具有较好的跨平台性:用户可能使用各种不同的操作系统,而且为了适应今后可能的变化,系统应具有较好的跨平台性。基于以上四点,在开发软件租用模块时,采用J2EE编程环境,并相应采用了专为J2EE定制的Struts框架。

做基于Struts框架的项目开发,关键是要有一个好的整体模型,计划好系统中包括哪几个模块,每个模块各需要什么样的FormBean、JavaBean,各种处理结果都通过哪些JSP页面来展现,同时配置好struts-config.xml文件。本系统的设计模型如图3所示。

ActionServlet接受所有的HTTP请求,然后根据配置文件的内容,决定将请求映射到哪一个Action对象,本系统中有两个Action对象,分别对应着登陆远程软件(LogonAction)和系统反馈密码(MailAction)。

LogonAction首先会验证用户是否已经登录,如果没有登录则重定向到登录页面(Logon.jsp),验证通过后根据请求参数决定下一步的处理,如果用户还没有选择租用软件，则转到软件介绍租用界面（Query.jsp），选择需要租用的软件或软件的某些模块，提交信息后，MailAction使服务器向用户提交密码，用户接收到密码后，登陆运行软件。

如果用户登陆软件成功，则通过配置文件struts-config.xml中的ActionForward，通过GetInfo对象把该用户租用的软件信息读取道FormBean中，然后调用JSP页面显示Bean里的数据。如果是保存数据信息,则调SaveInfo对象将FormBean里保持的信息存入数据库；如果是修改信息,则调ModifyInfo对象将FormBean里保持的修改后的信息存入数据库；如果是删除数据信息,则调用DeleteInfo对象将FormBean里保持的信息从数据库中删除。

经过这样设计的系统,用户界面和数据处理已经完全分离,再加上在JSP页面中使用了自定义标记,使页面中没有了Java的脚本代码,这样Web界面的设计和后端程序的编写就有了清晰的界线,便于开发团队的分工,并且维护起来也很方便。

结束语

Struts是一种非常优秀的基于J2EE的MVC应用框架,虽然从正式发布到现在也只有两年多的时间,但它已经越来越多地运用于企业平台之上,许多大型网站已成功地应用了Struts框架。本文在总结了Struts框架技术及其工作原理的基础上，结合“面向铸造行业的网络化制造ASP平台开发”项目，提出了在线租用模块的设计思路,这为今后更好的应用采用Struts框架提供了参考。

构建高性能的J2EE应用不但需要了解常用的实施技巧。下面介绍最常用的10种有效方法，可帮助架构设计师们快速成为这方面的专家。

Java性能的基础—内存管理

任何Java应用，单机的或J2EE的性能基础都可归结到你的应用是如何管理内存的问题。Java的内存管理包括两个重要任务：内存的分配和内存的回收。在内存的分配中，目标是要减少需要创建的对象。

内存回收是导致性能下降的普遍原因。也就是说，内存中的对象越多，垃圾回收越困难。所以我们对创建对象的态度应该越保守越好。

在J2EE应用中常见的两个内存有关的问题是：游离的对象（也被称为内存泄露）和对象循环（指大量频繁创建和删除-在Java中体现为解除引用---对象）。

我们应注意确保所有可到达的对象实际是活的，即这些对象不但在内存中，而且也要在执行的代码中是存在的。当对象在应用中已经没有用了，而我们却忘记了删除对该对象的引用时，游离的对象就出现了。

我们知道垃圾回收会占用CPU时间。短期对象的大量创建增加了垃圾回收的频率会造成性能下降。

不要在Servlet中实现业务逻辑

在构建J2EE应用时，架构工程师通常会使用到J2EE的基本部分——Servlet。如果架构师不使用Session Beans, Entity Beans, 或 Message Beans, 那么改进性能的方法就很少。只能采用增加CPU或更多的物理服务器等方法。EJB使用了缓存（cache）和资源池等方法可以提高性能和扩展性。

尽可能使用本地接口访问EJB

在早期的J2EE （遵循EJB1.X规范）应用中，访问EJB是`通过RMI使用远程接口实现的。随着EJB2.0的出现，可以通过本地接口访问EJB，不再使用RMI，在同一个JVM中使用远程方法已经少多了。但是现在还是有一些使用EJB1.X实现的应用和不知道使用本地接口的一些EJB新手。为说明这点，我们作个比较：

1、客户端应用调用本地Stub

2、该Stub装配参数

3、该Stub传到skeleton

4、该skeleton分解参数

5、该skeleton调用EJB对象

6、EJB对象执行容器服务

7、EJB对象调用企业BEAN实例

8、企业BEA执行操作

9、执行组装/分解步骤然后返回

与远程接口处理相比较，本地接口的EJB方法是：

1、客户端调用本地对象

2、本地对象执行容器服务

3、本地对象调用企业Bean实例

4、企业Bean实例执行操作

5、没有其他返回步骤！

如果你不需要从远程的客户端访问一个特殊EJB，就应该使用本地方法。

在实现Session Bean的服务中封装对实体EJB的访问

从Servlet访问实体EJB不但效率低而且难于维护。使用Session Facade（会话外观）模式可把对实体EJB的访问封装在会话EJB中，在该会话EJB中通过使用本地接口访问实体EJB而避免过多的远程调用。

这项技术会有额外的性能和扩展方面的好处，这是因为会话和实体EJB可以使用缓存和资源池技术来进行改进。另外，由于负载的需要，会话和实体EJB可被扩展部署到其他硬件设备上，这比将Servlet层复制扩展到其他硬件设备上要简单的多。

尽量粗粒度访问远程EJB

当访问远程EJB时，调用set/get方法将产生过多的网络请求，同时也导致远程接口处理的过载。为避免这种情况，可考虑将数据属性集中在一个对象中，这样通过一次对远程EJB的调用就可以传递所有数据。这项技术就是数据传输对象（Data Transfer Object）模式。

优化SQL

J2EE的架构设计工程师和开发人员通常不是SQL专家或经验丰富的数据库管理员。首先应该确保SQL使用了数据库提供的索引支持。在某些情况下，将数据库的索引和数据分开存放会提高性能。但要知道，增加额外的索引可以提高SELECT性能但也会降低INSERT的性能。对于某些数据库，关联表之间的排序会严重影响性能。可以多向数据库管理员咨询。

避免在实体EJB中过多执行SQL

有时候，通过实体EJB访问数据会执行多个SQL语句。根据J2EE 规范，第一步，将调用实体Bean的find(发现)方法；第二步，在第一次调用实体EJB的业务方法时，容器会调用ejbLoad()从数据库中获得信息。

很多CMP(容器管理持久性)在调用发现方法时就缓存了实体数据，所以在调用ejbLoad()时就不再访问数据库了。应该避免使用BMP(Bean管理的持久性)或者自己实现缓存算法避免二次访问数据库。

使用Fast Lane Reader 模式访问只读数据

J2EE应用经常要以只读方式访问大量长时间不变的数据，而不是访问单个实体，例如浏览在线产品目录。在这种只读情况下，使用实体EJB访问数据会导致严重过载并且实现很麻烦。实体EJB 适合于对单个实体的粗粒度访问，访问大量的列表只读数据时效率不高。不管是使用CMP还是BMP，一定需要编写代码操作多个实体EJB及其关联。这将导致访问多个数据库并存在大量的也是不必要的事务开销。

利用Java Messaging Servce(消息服务)

J2EE规范在JMS中提供了内置的异步处理服务。当涉及到系统需求时，应该了解在什么情况下应该采用JMS进行异步处理的设计。一旦确定要执行一些异步处理，那么同步处理的任务就应该越少越好，将数据库密集的操作安排在稍后的异步处理中完成。

缓存JNDI Lookup查找

很多操作在进行JNDI查找时要消耗大量资源。通常应该缓存JNDI资源避免网络调用和某些处理的过载。可以缓存的JNDI查找包括：

EJB Home Interfaces

Data Sources

JMS Connection Factories

MS Destinations/Topics

一些JNDI包实现了缓存功能。但是调用对EJB主接口的narrow方法时，这种功能作用有限。缓存查找的设计应该使用共享的IntialContext实例，尽管构建它很麻烦。这是因为需要访问多种数据源，包括应用资源文件JNDI.properties,系统属性的各项参数,传入到构造函数的各项参数。

Java语言内置了synchronized关键字用于对多线程进行同步，大大方便了Java中多线程程序的编写。但是仅仅使用synchronized关键字还不能满足对多线程进行同步的所有需要。大家知道，synchronized仅仅能够对方法或者代码块进行同步，如果我们一个应用需要跨越多个方法进行同步，synchroinzed就不能胜任了。在C++中有很多同步机制，比如信号量、互斥体、临届区等。在Java中也可以在synchronized语言特性的基础上，在更高层次构建这样的同步工具，以方便我们的使用。
    当前，广为使用的是由Doug Lea编写的一个Java中同步的工具包，可以在这儿了解更多这个包的详细情况：
    http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html
    该工具包已经作为JSR166正处于JCP的控制下，即将作为JDK1.5的正式组成部分。本文并不打算详细剖析这个工具包，而是对多种同步机制的一个介绍，同时给出这类同步机制的实例实现，这并不是工业级的实现。但其中会参考Doug Lea的这个同步包中的工业级实现的一些代码片断。
    本例中还沿用上篇中的Account类，不过我们这儿编写一个新的ATM类来模拟自动提款机，通过一个ATMTester的类，生成10个ATM线程，同时对John账户进行查询、提款和存款操作。Account类做了一些改动，以便适应本篇的需要：

在新的Account类中，我们采用一个HashMap来存储账户信息。Account由ATM类通过login登录后使用：

我们首先开发一个BusyFlag的类，类似于C++中的Simaphore。

注：参考Scott Oaks & Henry Wong《Java Thread》

BusyFlag有3个公开方法：getBusyFlag, freeBusyFlag, getOwner，分别用于获取忙标志、释放忙标志和获取当前占用忙标志的线程。使用这个BusyFlag也非常地简单，只需要在需要锁定的地方，调用BusyFlag的getBusyFlag()，在对锁定的资源使用完毕时，再调用改BusyFlag的freeBusyFlag()即可。下面我们开始改造上篇中的Account和ATM类，并应用BusyFlag工具类使得同时只有一个线程能够访问同一个账户的目标得以实现。首先，要改造Account类，在Account中内置了一个BusyFlag对象，并通过此标志对象对Account进行锁定和解锁：

新的Account提供了两个用于锁定的方法：lock()和unlock()，供Account对象的客户端在需要时锁定Account和解锁Account，Account通过委托给BusyFlag来提供这个机制。另外，大家也发现了，新的Account中提供了对Account对象的缓存，同时去除了public的构造方法，改为使用一个静态工厂方法供用户获取Account的实例，这样做也是有必要的，因为我们希望所有的ATM机同时只能有一个能够对同一个Account进行操作，我们在Account上的锁定是对一个特定Account对象进行加锁，如果多个ATM同时实例化多个同一个user的Account对象，那么仍然可以同时操作同一个账户。所以，要使用这种机制就必须保证Account对象在系统中的唯一性，所以，这儿使用一个Account的缓存，并将Account的构造方法变为私有的。你也可以说，通过在Account类锁上进行同步，即将Account中的BusyFlag对象声明为static的，但这样就使同时只能有一台ATM机进行操作了。这样，在一台ATM机在操作时，全市其它的所有的ATM机都必须等待。
另外必须注意的一点是：Account中的getAccount()方法必须同步，否则，将有可能生成多个Account对象，因为可能多个线程同时到达这个方法，并监测到accounts中没有“John”的Account实例，从而实例化多个John的Account实例。s

ATM类只需作少量改动，在login方法中锁定Account，在logout方法中解锁：

ATMTester类不需要做任何修改即可同样运行，同时保证同一个Account同时只能由一个ATM进行操作。解决了上篇提到的多个ATM同时对同一个Account进行操作造成的问题。

在最新的Doug Lea的util.concurrent工具包中（现处于JSR166）提供了类似的并发实用类：ReentrantLock，它实现了java .util.concurrent.locks.Lock接口（将在JDK1.5中发布），它的作用也类似于我们这儿的BusyFlag，实现机制、使用方法也相似。但这是一个工业强度的可重入锁的实现类。在ReentrantLock的API文档中有它的使用示例：

 　　Hibernate是一个中间层，它的目的是把数据库中的关系通过一定的规则映射成为对象，让Java开发人员不用太多的考虑底层数据库的问题，只需要像通常情况下管理对象一样的管理数据。在关系数据库仍将持续占据市场的情况下，它很可观。在数据持久化领域，即便是轻量级的方案也会是复杂饶舌的，也许如同周杰伦的音乐一样不知所云。在学习它之前，最好先回想一下以前进行数据库开发中遇到的问题和不便，想想为什么需要一个持久化层，才能知道很多操作的目的是什么，以及为什么要这么干，在这个问题上我不想做更多的叙述，因为“长久以来……”这样的句式通常long（不好意思，打不出来）长，会对我的键盘和热情造成很大的磨损。如果让我写一本书，那么我会乐意去叙述什么是数据持久化，它有什么好处等等。废话少说，来了。

 　　首先需要配置环境，下载Hibernate 2.1(www.hibernate.org)，把lib下的*.jar添加到classpath，你的数据库JDBC驱动程序也应该在classpath中。打开hibernate.properties，针对你使用的数据库，配置相应的信息，比如我使用的是MS SQL Server，配置如下：

 ## MS SQL Server

 hibernate.dialect net.sf.hibernate.dialect.SQLServerDialect
 hibernate.connection.driver_class com.microsoft.jdbc.sqlserver.SQLServerDriver
 hibernate.connection.url jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=zizz
 hibernate.connection.username sa
 hibernate.connection.password

 　　其中很大部分是已经写好的，只需要取掉注释即可，我自己只是修改了数据库名称、帐号、密码。建立一个名为zizz的数据库备用。

 　　然后把这个文件拷贝到你的应用的根目录下。

 　　我们谈论了很多次映射，应该首先来看看这个映射是如何完成的。假设一个最简单的应用，写一个功能最单一的留言板，设计的数据有留言的编号、留言者名称、留言内容，还有留言时间。足够简单吧，换做是你打算怎么干？我猜你要首先建立一个数据库表格，名字也许叫做guestbook。No，这不是面向对象的方式，不妨首先从对象的角度来考虑。我们当然希望每一条留言都以对象的方式呈现，每个对象应该具有的属性有：id、author、content、time。偷个懒，没有画UML。下面这个类应该是很容易理解的：

 //GuestBook.java
 package org.bromon.zizz;

 import java.util.*;

 public class GuestBook
 {
 private int id;
 private String author;
 private String content;
 private Calendar time;

 private void setId(int id)
 {
  this.id=id;
 }
 public int getId()
 {
  return(id);
 }

 public void setAuthor(String author)
 {
  this.author=author;
 }
 public String getAuthro()
 {
  return(author);
 }

 public void setContent(String content)
 {
  this.content=content;
 }
 public String getContent()
 {
  return(content);
 }

 public void setTime(Calendar time)
 {
  this.time=time;
 }
 public Calendar getTime()
 {
  return(time);
 }
 }

Alt+左箭头,右箭头        以在编辑窗口切换标签
Alt+上下箭头,                以自动选择鼠标所在行,并将其上下移动
Ctrl+f6                            可以弹出菜单,上面列出可以切换的编辑窗口,这样不用鼠标也可切换
Ctrl+f7                            可以在视图之间切换 ,如编辑视图,输出视图,工程视图
Ctrl+f8                            可以在不同的观察视图中切换,就是在java视图,调试视图,等之间切换
Ctrl+m                            可以在最大化当前窗口和还原当前窗口之间切换
Ctrl+e                              弹出输入窗口,可以输入你想要编辑的代码窗口,和Ctrl+f6的功能相同,只不过一个是选择的方式,一个是输入的方式,切换窗口
Ctrl+T                              可以直接显示光标所在内容的类图,可以直接输入,并跳到输入内容部分
按住Ctrl键，然后鼠标指向变量名，方法名，类名       在源代码中快速跳转 
Ctrl + F11                      快速执行程序
Ctrl+Shift+F                   程序代码自动排版
Ctrl+Shift+O                 自动加入引用。说明： 假设我们没有Import任何类别时，当我们在程序里打入： ResourceAttirbute ra =new ResourceAttribute();  Eclipse会提示说没有引用类别，这时我们只要按下Ctrl+Shift+O ，它就会自动帮我们Import这个类别。 非常方便
Ctrl+/                            将选取的块注释起来：在Debug时很方便。 
Alt + /                           就是大家都应该最常用的代码辅助了
Ctrl+h                           搜索,打开搜索对话框
Ctrl+Shift+Space          参数提示,如果此时位于方法体中,就会出现方法的参数提示,当前光标所在位置的参数会用粗体显示

作用域 功能 快捷键 
全局 查找并替换 Ctrl+F 
文本编辑器 查找上一个 Ctrl+Shift+K 
文本编辑器 查找下一个 Ctrl+K 
全局 撤销 Ctrl+Z 
全局 复制 Ctrl+C 
全局 恢复上一个选择 Alt+Shift+↓ 
全局 剪切 Ctrl+X 
全局 快速修正 Ctrl1+1 
全局 内容辅助 Alt+/ 
全局 全部选中 Ctrl+A 
全局 删除 Delete 
全局 上下文信息 Alt+？
Alt+Shift+?
Ctrl+Shift+Space 
Java编辑器 显示工具提示描述 F2 
Java编辑器 选择封装元素 Alt+Shift+↑ 
Java编辑器 选择上一个元素 Alt+Shift+← 
Java编辑器 选择下一个元素 Alt+Shift+→ 
文本编辑器 增量查找 Ctrl+J 
文本编辑器 增量逆向查找 Ctrl+Shift+J 
全局 粘贴 Ctrl+V 
全局 重做 Ctrl+Y 


查看
作用域 功能 快捷键 
全局 放大 Ctrl+= 
全局 缩小 Ctrl+- 


窗口
作用域 功能 快捷键 
全局 激活编辑器 F12 
全局 切换编辑器 Ctrl+Shift+W 
全局 上一个编辑器 Ctrl+Shift+F6 
全局 上一个视图 Ctrl+Shift+F7 
全局 上一个透视图 Ctrl+Shift+F8 
全局 下一个编辑器 Ctrl+F6 
全局 下一个视图 Ctrl+F7 
全局 下一个透视图 Ctrl+F8 
文本编辑器 显示标尺上下文菜单 Ctrl+W 
全局 显示视图菜单 Ctrl+F10 
全局 显示系统菜单 Alt+- 


导航
作用域 功能 快捷键 
Java编辑器 打开结构 Ctrl+F3 
全局 打开类型 Ctrl+Shift+T 
全局 打开类型层次结构 F4 
全局 打开声明 F3 
全局 打开外部javadoc Shift+F2 
全局 打开资源 Ctrl+Shift+R 
全局 后退历史记录 Alt+← 
全局 前进历史记录 Alt+→ 
全局 上一个 Ctrl+, 
全局 下一个 Ctrl+. 
Java编辑器 显示大纲 Ctrl+O 
全局 在层次结构中打开类型 Ctrl+Shift+H 
全局 转至匹配的括号 Ctrl+Shift+P 
全局 转至上一个编辑位置 Ctrl+Q 
Java编辑器 转至上一个成员 Ctrl+Shift+↑ 
Java编辑器 转至下一个成员 Ctrl+Shift+↓ 
文本编辑器 转至行 Ctrl+L 


搜索
作用域 功能 快捷键 
全局 出现在文件中 Ctrl+Shift+U 
全局 打开搜索对话框 Ctrl+H 
全局 工作区中的声明 Ctrl+G 
全局 工作区中的引用 Ctrl+Shift+G 


文本编辑
作用域 功能 快捷键 
文本编辑器 改写切换 Insert 
文本编辑器 上滚行 Ctrl+↑ 
文本编辑器 下滚行 Ctrl+↓ 


文件
作用域 功能 快捷键 
全局 保存 Ctrl+X 
Ctrl+S 
全局 打印 Ctrl+P 
全局 关闭 Ctrl+F4 
全局 全部保存 Ctrl+Shift+S 
全局 全部关闭 Ctrl+Shift+F4 
全局 属性 Alt+Enter 
全局 新建 Ctrl+N 


项目
作用域 功能 快捷键 
全局 全部构建 Ctrl+B 


源代码
作用域 功能 快捷键 
Java编辑器 格式化 Ctrl+Shift+F 
Java编辑器 取消注释 Ctrl+\ 
Java编辑器 注释 Ctrl+/ 
Java编辑器 添加导入 Ctrl+Shift+M 
Java编辑器 组织导入 Ctrl+Shift+O 
Java编辑器 使用try/catch块来包围 未设置，太常用了，所以在这里列出,建议自己设置。
也可以使用Ctrl+1自动修正。 


运行
作用域 功能 快捷键 
全局 单步返回 F7 
全局 单步跳过 F6 
全局 单步跳入 F5 
全局 单步跳入选择 Ctrl+F5 
全局 调试上次启动 F11 
全局 继续 F8 
全局 使用过滤器单步执行 Shift+F5 
全局 添加/去除断点 Ctrl+Shift+B 
全局 显示 Ctrl+D 
全局 运行上次启动 Ctrl+F11 
全局 运行至行 Ctrl+R 
全局 执行 Ctrl+U 


重构
作用域 功能 快捷键 
全局 撤销重构 Alt+Shift+Z 
全局 抽取方法 Alt+Shift+M 
全局 抽取局部变量 Alt+Shift+L 
全局 内联 Alt+Shift+I 
全局 移动 Alt+Shift+V 
全局 重命名 Alt+Shift+R 
全局 重做 Alt+Shift+Y 

热键篇：Template：Alt + /修改处：窗口->喜好设定->工作台->按键->编辑->内容辅助。个人习惯：Shift+SPACE(空白)。简易说明：编辑程序代码时，打sysout +Template启动键，就会自动出现：System.out.println(); 。设定Template的格式：窗口->喜好设定->Java->编辑器->模板。程序代码自动排版：Ctrl+Shift+F修改处：窗口->喜好设定->工作台->按键->程序代码->格式。个人习惯：Alt+Z。自动排版设定：窗口->喜好设定->Java->程序代码格式制作程序。样式页面->将插入tab(而非空格键)以内缩，该选项取消勾选，下面空格数目填4，这样在自动编排时会以空格4作缩排。快速执行程序：Ctrl + F11个人习惯：ALT+X修改处：窗口->喜好设定->工作台->按键->执行->启动前一次的启动作业。简易说明：第一次执行时，它会询问您执行模式，设置好后，以后只要按这个热键，它就会快速执行。
<ALT+Z(排版完)、ATL+X(执行)>..我觉得很顺手^___^自动汇入所需要的类别：Ctrl+Shift+O简易说明：假设我们没有Import任何类别时，当我们在程序里打入：

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

此时Eclipse会警示说没有汇入类别，这时我们只要按下Ctrl+Shift+O，它就会自动帮我们Import类别。查看使用类别的原始码：Ctrl+鼠标左键点击简易说明：可以看到您所使用类别的原始码。将选取的文字批注起来：Ctrl+/简易说明：Debug时很方便。修改处：窗口->喜好设定->工作台->按键->程序代码->批注视景切换：Ctrl+F8个人习惯：Alt+S。修改处：窗口->喜好设定->工作台->按键->窗口->下一个视景。简易说明：可以方便我们快速切换编辑、除错等视景。密技篇：一套Eclipse可同时切换，英文、繁体、简体显示：
1.首先要先安装完中文化包。
2.在桌面的快捷方式后面加上参数即可，英文-> -nl "zh_US"繁体-> -nl "zh_TW"简体-> -nl "zh_CN"。
(其它语系以此类推)像我2.1.2中文化后，我在我桌面的Eclipse快捷方式加入参数-n1 "zh_US"。
"C:\Program Files\eclipse\eclipse.exe" -n "zh_US"接口就会变回英文语系噜。利用Eclipse，在Word编辑文书时可不必将程序代码重新编排：将Eclipse程序编辑区的程序代码整个复制下来(Ctrl+C)，直接贴(Ctrl+V)到
Word或WordPad上，您将会发现在Word里的程序代码格式，跟Eclipse所设定的完全一样，包括字型、缩排、关键词颜色。我曾试过JBuilder、GEL、NetBeans...使用复制贴上时，只有缩排格式一样，字型、颜色等都不会改变。外挂篇：外挂安装：将外挂包下载回来后，将其解压缩后，您会发现features、
plugins这2个数据夹，将里面的东西都复制或移动到Eclipse的features、plugins数据夹内后，重新启动Eclipse即可。让Eclipse可以像JBuilderX一样使用拖拉方式建构GUI的外挂：
1.Jigloo SWT/Swing GUI Builder ：http://cloudgarden.com/jigloo/index.html下载此版本：Jigloo plugin for Eclipse (using Java 1.4 or 1.5)安装后即可由档案->新建->其它->GUI Form选取要建构的GUI类型。

2.Eclipse Visual Editor Project：http://www.eclipse.org/vep/点选下方Download Page，再点选Latest Release 0.5.0进入下载。除了VE-runtime-0.5.0.zip要下载外，以下这2个也要：
EMF build 1.1.1: (build page) (download zip) 
GEF Build 2.1.2: (build page) (download zip) 

3.0 M8版本，请下载：
EMF build I200403250631
GEF Build I20040330
VE-runtime-1.0M1安装成功后，便可由File->New->Visual Class开始UI设计。安装成功后，即可由新建->Java->AWT与Swing里选择所要建构的GUI类型开始进行设计。VE必须配合着对应版本，才能正常使用，否则即使安装成功，使用上仍会有问题。使用Eclipse来开发JSP程序：外挂名称：lomboz(下载页面)http://forge.objectweb.org/project/showfiles.php?group_id=97请选择适合自己版本的lomboz下载，lomboz.212.p1.zip表示2.1.2版，
lomboz.3m7.zip表示M7版本....以此类推。
lomboz安装以及设置教学：Eclipse开发JSP-教学文件

Java转exe篇：实现方式：Eclipse搭配JSmooth(免费)。
1.先由Eclipse制作包含Manifest的JAR。制作教学
2.使用JSmooth将做好的JAR包装成EXE。
JSmooth下载页面：http://jsmooth.sourceforge.net/index.php
3.制作完成的exe文件，可在有装置JRE的Windows上执行。

Eclipse-Java编辑器最佳设定：编辑器字型设定：工作台->字型->Java编辑器文字字型。
(建议设定Courier New -regular 10)编辑器相关设定：窗口->喜好设定->Java->编辑器外观：显示行号、强调对称显示的方括号、强调显示现行行、显示打印边距，将其勾选，Tab宽度设4，打印编距字段设80。程序代码协助：采预设即可。语法：可设定关键词、字符串等等的显示颜色。附注：采预设即可。输入：全部字段都勾选。浮动说明：采预设即可。导览：采预设即可。使自动排版排出来的效果，最符合Java设计惯例的设定：自动排版设定：窗口->喜好设定->Java->程序代码制作格式。换行：全部不勾选。分行：行长度上限设：80。样式：只将强制转型后插入空白勾选。内缩空格数目：设为4。

1. Control-Shift-T: 打开类型（Open type）。如果你不是有意磨洋工，还是忘记通过源码树（source tree）打开的方式吧。

2. Control-Shift-R: 打开资源（不只是用来寻找Java文件）。小提示：利用Navigator视图的黄色双向箭头按钮让你的编辑窗口和导航器相关联。这会让你打开的文件对应显示在导航器的层级结构中，这样便于组织信息。如果这影响了速度，就关掉它。

3. F3: 打开申明（Open declaration）。或者，利用Declaration Tab（在Java视图模式下，选择Windows --> Show View -- > Declaration）。当你选中代码中的一个方法，然后按这个按键，它会把整个方法在申明方框里显示出来。

4. Alt-left arrow: 在导航历史记录（Navigation History）中后退。就像Web浏览器的后退按钮一样，在利用F3跳转之后，特别有用。（用来返回原先编译的地方）

5. Alt-right arrow: 导航历史记录中向前。

6. Control-Q: 回到最后依次编辑的地方。这个快捷键也是当你在代码中跳转后用的。特别是当你钻的过深，忘记你最初在做什么的时候。

7. Control-Shift-G: 在workspace中搜索引用（reference）。这是重构的前提。对于方法，这个热键的作用和F3恰好相反。它使你在方法的栈中，向上找出一个方法的所有调用者。一个与此相关的功能是开启“标记”功能（occurrence marking） 。选择Windows->Preferences->Java-> Editor-> Mark Occurrences，勾选选项。这时，当你单击一个元素的时候，代码中所有该元素存在的地方都会被高亮显示。我个人只使用“标记本地变量”（Mark Local Variables）。注意：太多的高亮显示会拖慢Eclipse。

8. Control-Shift-F: 根据代码风格设定重新格式化代码。我们的团队有统一的代码格式，我们把它放在我们的wiki上。要这么做，我们打开Eclipse，选择WindowPreferencesJavaCode Style，然后设置Code Formatter，Code Style和Organize Imports。利用导出（Export）功能来生成配置文件。我们把这些配置文件放在wiki上，然后团队里的每个人都导入到自己的Eclipse中。

9. Control-O: 快速概要(quick outline)。通过这个快捷键，你可以迅速的跳到一个方法或者属性，只需要输入名字的头几个字母。 

10. Control-/: 对一行注释或取消注释。对于多行也同样适用。

11. Control-Alt-down arrow: 复制高亮显示的一行或多行。

12. Alt-down arrow: 将一行或多行向下移动。Alt-up arrow会向上移动。

其他的热键在菜单里有。你可以通过按下Control-Shift-L（从3.1版本开始），看到所有快捷键的列表。按下Control-Shift-L两次，会显示热键对话框（Keys Preferences dialog），你可以在这里自己设置热键。我欢迎你在Talkback部分发表你的Eclipse提示。


Ctrl+1 快速修复(最经典的快捷键,就不用多说了)

Ctrl+D: 删除当前行

Ctrl+Alt+↓ 复制当前行到下一行(复制增加)

Ctrl+Alt+↑ 复制当前行到上一行(复制增加)

Alt+↓ 当前行和下面一行交互位置(特别实用,可以省去先剪切,再粘贴了)

Alt+↑ 当前行和上面一行交互位置(同上)

Alt+← 前一个编辑的页面

Alt+→ 下一个编辑的页面(当然是针对上面那条来说了)

Alt+Enter 显示当前选择资源(工程,or 文件 or文件)的属性

Shift+Enter 在当前行的下一行插入空行(这时鼠标可以在当前行的任一位置,不一定是最后)

Shift+Ctrl+Enter 在当前行插入空行(原理同上条)

Ctrl+Q 定位到最后编辑的地方

Ctrl+L 定位在某行 (对于程序超过100的人就有福音了)

Ctrl+M 最大化当前的Edit或View (再按则反之)

Ctrl+/ 注释当前行,再按则取消注释

Ctrl+O 快速显示 OutLine

Ctrl+T 快速显示当前类的继承结构

Ctrl+W 关闭当前Editer

Ctrl+K 参照选中的Word快速定位到下一个

Ctrl+E 快速显示当前Editer的下拉列表(如果当前页面没有显示的用黑体表示)

Ctrl+/(小键盘) 折叠当前类中的所有代码

Ctrl+×(小键盘) 展开当前类中的所有代码

Ctrl+Space 代码助手完成一些代码的插入(但一般和输入法有冲突,可以修改输入法的热键,也可以暂用Alt+/来代替)

Ctrl+Shift+E 显示管理当前打开的所有的View的管理器(可以选择关闭,激活等操作)

Ctrl+J 正向增量查找(按下Ctrl+J后,你所输入的每个字母编辑器都提供快速匹配定位到某个单词,如果没有,则在stutes line中显示没有找到了,查一个单词时,特别实用,这个功能Idea两年前就有了)

Ctrl+Shift+J 反向增量查找(和上条相同,只不过是从后往前查)

Ctrl+Shift+F4 关闭所有打开的Editer

Ctrl+Shift+X 把当前选中的文本全部变味小写

Ctrl+Shift+Y 把当前选中的文本全部变为小写

Ctrl+Shift+F 格式化当前代码

Ctrl+Shift+P 定位到对于的匹配符(譬如{}) (从前面定位后面时,光标要在匹配符里面,后面到前面,则反之)

下面的快捷键是重构里面常用的,本人就自己喜欢且常用的整理一下(注:一般重构的快捷键都是Alt+Shift开头的了)

Alt+Shift+R 重命名 (是我自己最爱用的一个了,尤其是变量和类的Rename,比手工方法能节省很多劳动力)

Alt+Shift+M 抽取方法 (这是重构里面最常用的方法之一了,尤其是对一大堆泥团代码有用)

Alt+Shift+C 修改函数结构(比较实用,有N个函数调用了这个方法,修改一次搞定)

Alt+Shift+L 抽取本地变量( 可以直接把一些魔法数字和字符串抽取成一个变量,尤其是多处调用的时候)

Alt+Shift+F 把Class中的local变量变为field变量 (比较实用的功能)

Alt+Shift+I 合并变量(可能这样说有点不妥Inline)

Alt+Shift+V 移动函数和变量(不怎么常用)

Alt+Shift+Z 重构的后悔药(Undo)


经常用到的Eclipse快捷键
存盘 Ctrl+s(一定记住)
注释代码 Ctrl+/
取消注释 Ctrl+\(Eclipse3已经都合并到Ctrl+/了)
代码辅助 Alt+/
快速修复 Ctrl+1
代码格式化 Ctrl+Shift+f
整理导入 Ctrl+Shift+o
切换窗口 Ctrl+f6<可改为ctrl+tab方便>
ctrl+shift+M 导入未引用的包
ctrl+w 关闭单个窗口
F3 跳转到类、变量的声明
F11 运行上次程序
Ctrl + F11 调试上次程序
Alt + 回下一个编辑点
ctrl+shift+T 查找工程中的类

基于Java的全文索引/检索引擎——Lucene

Lucene不是一个完整的全文索引应用，而是是一个用Java写的全文索引引擎工具包，它可以方便的嵌入到各种应用中实现针对应用的全文索引/检索功能。

Lucene的作者：Lucene的贡献者Doug Cutting是一位资深全文索引/检索专家，曾经是V-Twin搜索引擎(Apple的Copland操作系统的成就之一)的主要开发者，后在Excite担任高级系统架构设计师，目前从事于一些INTERNET底层架构的研究。他贡献出的Lucene的目标是为各种中小型应用程序加入全文检索功能。

Lucene的发展历程：早先发布在作者自己的www.lucene.com，后来发布在SourceForge，2001年年底成为APACHE基金会jakarta的一个子项目：http://jakarta.apache.org/lucene/

已经有很多Java项目都使用了Lucene作为其后台的全文索引引擎，比较著名的有：

• J ive：WEB论坛系统；
• Eyebrows：邮件列表HTML归档/浏览/查询系统，本文的主要参考文档“TheLucene search engine: Powerful, flexible, and free”作者就是EyeBrows系统的主要开发者之一，而EyeBrows已经成为目前APACHE项目的主要邮件列表归档系统。
• Cocoon:基于XML的web发布框架，全文检索部分使用了Lucene

• Eclipse:基于Java的开放开发平台，帮助部分的全文索引使用了Lucene

对于中文用户来说，最关心的问题是其是否支持中文的全文检索。但通过后面对于Lucene的结构的介绍，你会了解到由于Lucene良好架构设计，对中文的支持只需对其语言词法分析接口进行扩展就能实现对中文检索的支持。

全文检索的实现机制

Lucene的API接口设计的比较通用，输入输出结构都很像数据库的表==>记录==>字段，所以很多传统的应用的文件、数据库等都可以比较方便的映射到Lucene的存储结构/接口中。总体上看：可以先把Lucene当成一个支持全文索引的数据库系统。

比较一下Lucene和数据库：

索引数据源：doc(field1,field2...) doc(field1,field2...)
                  \  indexer /
                 _____________
                | Lucene Index|
                --------------
                 / searcher \
 结果输出：Hits(doc(field1,field2) doc(field1...))

 索引数据源：record(field1,field2...) record(field1..)
              \  SQL: insert/
               _____________
              | DB  Index   |
               -------------
              / SQL: select \
结果输出：results(record(field1,field2..) record(field1...))

全文检索 ≠ like "%keyword%"

通常比较厚的书籍后面常常附关键词索引表（比如：北京：12, 34页，上海：3,77页……），它能够帮助读者比较快地找到相关内容的页码。而数据库索引能够大大提高查询的速度原理也是一样，想像一下通过书后面的索引查找的速度要比一页一页地翻内容高多少倍……而索引之所以效率高，另外一个原因是它是排好序的。对于检索系统来说核心是一个排序问题。

由于数据库索引不是为全文索引设计的，因此，使用like "%keyword%"时，数据库索引是不起作用的，在使用like查询时，搜索过程又变成类似于一页页翻书的遍历过程了，所以对于含有模糊查询的数据库服务来说，LIKE对性能的危害是极大的。如果是需要对多个关键词进行模糊匹配：like"%keyword1%" and like "%keyword2%" ...其效率也就可想而知了。

所以建立一个高效检索系统的关键是建立一个类似于科技索引一样的反向索引机制，将数据源（比如多篇文章）排序顺序存储的同时，有另外一个排好序的关键词列表，用于存储关键词==>文章映射关系，利用这样的映射关系索引：[关键词==>出现关键词的文章编号，出现次数（甚至包括位置：起始偏移量，结束偏移量），出现频率]，检索过程就是把模糊查询变成多个可以利用索引的精确查询的逻辑组合的过程。从而大大提高了多关键词查询的效率，所以，全文检索问题归结到最后是一个排序问题。

由此可以看出模糊查询相对数据库的精确查询是一个非常不确定的问题，这也是大部分数据库对全文检索支持有限的原因。Lucene最核心的特征是通过特殊的索引结构实现了传统数据库不擅长的全文索引机制，并提供了扩展接口，以方便针对不同应用的定制。

可以通过一下表格对比一下数据库的模糊查询：

	Lucene全文索引引擎	数据库
索引	将数据源中的数据都通过全文索引一一建立反向索引	对于LIKE查询来说，数据传统的索引是根本用不上的。数据需要逐个便利记录进行GREP式的模糊匹配，比有索引的搜索速度要有多个数量级的下降。
匹配效果	通过词元(term)进行匹配，通过语言分析接口的实现，可以实现对中文等非英语的支持。	使用：like "%net%" 会把netherlands也匹配出来， 多个关键词的模糊匹配：使用like "%com%net%"：就不能匹配词序颠倒的xxx.net..xxx.com
匹配度	有匹配度算法，将匹配程度（相似度）比较高的结果排在前面。	没有匹配程度的控制：比如有记录中net出现5词和出现1次的，结果是一样的。
结果输出	通过特别的算法，将最匹配度最高的头100条结果输出，结果集是缓冲式的小批量读取的。	返回所有的结果集，在匹配条目非常多的时候（比如上万条）需要大量的内存存放这些临时结果集。
可定制性	通过不同的语言分析接口实现，可以方便的定制出符合应用需要的索引规则（包括对中文的支持）	没有接口或接口复杂，无法定制
结论	高负载的模糊查询应用，需要负责的模糊查询的规则，索引的资料量比较大	使用率低，模糊匹配规则简单或者需要模糊查询的资料量少

全文检索和数据库应用最大的不同在于：让 最相关的 头100条结果满足98%以上用户的需求

Lucene的创新之处：

大部分的搜索（数据库）引擎都是用B树结构来维护索引，索引的更新会导致大量的IO操作，Lucene在实现中，对此稍微有所改进：不是维护一个索引文件，而是在扩展索引的时候不断创建新的索引文件，然后定期的把这些新的小索引文件合并到原先的大索引中（针对不同的更新策略，批次的大小可以调整），这样在不影响检索的效率的前提下，提高了索引的效率。

Lucene和其他一些全文检索系统/应用的比较：

关于亚洲语言的的切分词问题(Word Segment)

对于中文来说，全文索引首先还要解决一个语言分析的问题，对于英文来说，语句中单词之间是天然通过空格分开的，但亚洲语言的中日韩文语句中的字是一个字挨一个，所有，首先要把语句中按“词”进行索引的话，这个词如何切分出来就是一个很大的问题。

首先，肯定不能用单个字符作(si-gram)为索引单元，否则查“上海”时，不能让含有“海上”也匹配。

但一句话：“北京天安门”，计算机如何按照中文的语言习惯进行切分呢？
“北京 天安门” 还是“北 京 天安门”？让计算机能够按照语言习惯进行切分，往往需要机器有一个比较丰富的词库才能够比较准确的识别出语句中的单词。

另外一个解决的办法是采用自动切分算法：将单词按照2元语法(bigram)方式切分出来，比如：
"北京天安门" ==> "北京 京天 天安 安门"。

这样，在查询的时候，无论是查询"北京" 还是查询"天安门"，将查询词组按同样的规则进行切分："北京"，"天安安门"，多个关键词之间按与"and"的关系组合，同样能够正确地映射到相应的索引中。这种方式对于其他亚洲语言：韩文，日文都是通用的。

基于自动切分的最大优点是没有词表维护成本，实现简单，缺点是索引效率低，但对于中小型应用来说，基于2元语法的切分还是够用的。基于2元切分后的索引一般大小和源文件差不多，而对于英文，索引文件一般只有原文件的30%-40%不同，

目前比较大的搜索引擎的语言分析算法一般是基于以上2个机制的结合。关于中文的语言分析算法，大家可以在Google查关键词"wordsegment search"能找到更多相关的资料。

安装和使用

下载：http://jakarta.apache.org/lucene/

注意：Lucene中的一些比较复杂的词法分析是用JavaCC生成的（JavaCC：JavaCompilerCompiler，纯Java的词法分析生成器），所以如果从源代码编译或需要修改其中的QueryParser、定制自己的词法分析器，还需要从https://javacc.dev.java.net/下载javacc。

lucene的组成结构：对于外部应用来说索引模块(index)和检索模块(search)是主要的外部应用入口

简单的例子演示一下Lucene的使用方法：

public class IndexFiles { 
  //使用方法：: IndexFiles [索引输出目录] [索引的文件列表] ... 
  public static void main(String[] args) throws Exception {
    String indexPath = args[0];
    IndexWriter writer;
    //用指定的语言分析器构造一个新的写索引器（第3个参数表示是否为追加索引）
    writer = new IndexWriter(indexPath, new SimpleAnalyzer(), false);

    for (int i=1; i<args.length; i++) {
      System.out.println("Indexing file " + args[i]);
      InputStream is = new FileInputStream(args[i]);

      //构造包含2个字段Field的Document对象
      //一个是路径path字段，不索引，只存储
      //一个是内容body字段，进行全文索引，并存储
      Document doc = new Document();
      doc.add(Field.UnIndexed("path", args[i]));
      doc.add(Field.Text("body", (Reader) new InputStreamReader(is)));
      //将文档写入索引
      writer.addDocument(doc);
      is.close();
    };
    //关闭写索引器
    writer.close();
  }
}
　

索引过程中可以看到：

• 语言分析器提供了抽象的接口，因此语言分析(Analyser)是可以定制的，虽然lucene缺省提供了2个比较通用的分析器SimpleAnalyser和StandardAnalyser，这2个分析器缺省都不支持中文，所以要加入对中文语言的切分规则，需要修改这2个分析器。
• Lucene并没有规定数据源的格式，而只提供了一个通用的结构（Document对象）来接受索引的输入，因此输入的数据源可以是：数据库，WORD文档，PDF文档，HTML文档……只要能够设计相应的解析转换器将数据源构造成成Docuement对象即可进行索引。
• 对于大批量的数据索引，还可以通过调整IndexerWrite的文件合并频率属性（mergeFactor）来提高批量索引的效率。

检索过程和结果显示：

搜索结果返回的是Hits对象，可以通过它再访问Document==>Field中的内容。

假设根据body字段进行全文检索，可以将查询结果的path字段和相应查询的匹配度(score)打印出来，

public class Search { 
  public static void main(String[] args) throws Exception {
    String indexPath = args[0], queryString = args[1];
    //指向索引目录的搜索器
    Searcher searcher = new IndexSearcher(indexPath);
    //查询解析器：使用和索引同样的语言分析器
    Query query = QueryParser.parse(queryString, "body", 
                              new SimpleAnalyzer());
    //搜索结果使用Hits存储
    Hits hits = searcher.search(query);
    //通过hits可以访问到相应字段的数据和查询的匹配度
    for (int i=0; i<hits.length(); i++) {
      System.out.println(hits.doc(i).get("path") + "; Score: " + 
                         hits.score(i));
    };
  }
}

Hacking Lucene

简化的查询分析器

个人感觉lucene成为JAKARTA项目后，画在了太多的时间用于调试日趋复杂QueryParser，而其中大部分是大多数用户并不很熟悉的，目前LUCENE支持的语法：

Query ::= ( Clause )*
Clause ::= ["+", "-"] [<TERM> ":"] ( <TERM> | "(" Query ")")

中间的逻辑包括：and or + - &&||等符号，而且还有"短语查询"和针对西文的前缀/模糊查询等，个人感觉对于一般应用来说，这些功能有一些华而不实，其实能够实现目前类似于Google的查询语句分析功能其实对于大多数用户来说已经够了。所以，Lucene早期版本的QueryParser仍是比较好的选择。

添加修改删除指定记录（Document）

Lucene提供了索引的扩展机制，因此索引的动态扩展应该是没有问题的，而指定记录的修改也似乎只能通过记录的删除，然后重新加入实现。如何删除指定的记录呢？删除的方法也很简单，只是需要在索引时根据数据源中的记录ID专门另建索引，然后利用IndexReader.delete(Termterm)方法通过这个记录ID删除相应的Document。

根据某个字段值的排序功能

lucene缺省是按照自己的相关度算法（score）进行结果排序的，但能够根据其他字段进行结果排序是一个在LUCENE的开发邮件列表中经常提到的问题，很多原先基于数据库应用都需要除了基于匹配度（score）以外的排序功能。而从全文检索的原理我们可以了解到，任何不基于索引的搜索过程效率都会导致效率非常的低，如果基于其他字段的排序需要在搜索过程中访问存储字段，速度回大大降低，因此非常是不可取的。

但这里也有一个折中的解决方法：在搜索过程中能够影响排序结果的只有索引中已经存储的docID和score这2个参数，所以，基于score以外的排序，其实可以通过将数据源预先排好序，然后根据docID进行排序来实现。这样就避免了在LUCENE搜索结果外对结果再次进行排序和在搜索过程中访问不在索引中的某个字段值。

这里需要修改的是IndexSearcher中的HitCollector过程：

...
　scorer.score(new HitCollector() {
	private float minScore = 0.0f;
	public final void collect(int doc, float score) {
	  if (score > 0.0f &&			  // ignore zeroed buckets
	      (bits==null || bits.get(doc))) {	  // skip docs not in bits
	    totalHits[0]++;
	    if (score >= minScore) {
              /* 原先：Lucene将docID和相应的匹配度score例入结果命中列表中：
	       * hq.put(new ScoreDoc(doc, score));	  // update hit queue
               * 如果用doc 或 1/doc 代替 score，就实现了根据docID顺排或逆排
               * 假设数据源索引时已经按照某个字段排好了序，而结果根据docID排序也就实现了
               * 针对某个字段的排序，甚至可以实现更复杂的score和docID的拟合。
               */
              hq.put(new ScoreDoc(doc, (float) 1/doc )); 
	      if (hq.size() > nDocs) {		  // if hit queue overfull
		hq.pop();			  // remove lowest in hit queue
		minScore = ((ScoreDoc)hq.top()).score; // reset minScore
	      }
	    }
	  }
	}
      }, reader.maxDoc());

更通用的输入输出接口

虽然lucene没有定义一个确定的输入文档格式，但越来越多的人想到使用一个标准的中间格式作为Lucene的数据导入接口，然后其他数据，比如PDF只需要通过解析器转换成标准的中间格式就可以进行数据索引了。这个中间格式主要以XML为主，类似实现已经不下4，5个：

数据源: WORD       PDF     HTML    DB       other
         \          |       |      |         /
                       XML中间格式
                            |
                     Lucene INDEX

目前还没有针对MSWord文档的解析器，因为Word文档和基于ASCII的RTF文档不同，需要使用COM对象机制解析。这个是我在Google上查的相关资料：http://www.intrinsyc.com/products/enterprise_applications.asp
另外一个办法就是把Word文档转换成text：http://www.winfield.demon.nl/index.html

索引过程优化

索引一般分2种情况，一种是小批量的索引扩展，一种是大批量的索引重建。在索引过程中，并不是每次新的DOC加入进去索引都重新进行一次索引文件的写入操作（文件I/O是一件非常消耗资源的事情）。

Lucene先在内存中进行索引操作，并根据一定的批量进行文件的写入。这个批次的间隔越大，文件的写入次数越少，但占用内存会很多。反之占用内存少，但文件IO操作频繁，索引速度会很慢。在IndexWriter中有一个MERGE_FACTOR参数可以帮助你在构造索引器后根据应用环境的情况充分利用内存减少文件的操作。根据我的使用经验：缺省Indexer是每20条记录索引后写入一次，每将MERGE_FACTOR增加50倍，索引速度可以提高1倍左右。

搜索过程优化

lucene支持内存索引：这样的搜索比基于文件的I/O有数量级的速度提升。
http://www.onjava.com/lpt/a/3273
而尽可能减少IndexSearcher的创建和对搜索结果的前台的缓存也是必要的。

Lucene面向全文检索的优化在于首次索引检索后，并不把所有的记录（Document）具体内容读取出来，而起只将所有结果中匹配度最高的头100条结果（TopDocs）的ID放到结果集缓存中并返回，这里可以比较一下数据库检索：如果是一个10,000条的数据库检索结果集，数据库是一定要把所有记录内容都取得以后再开始返回给应用结果集的。所以即使检索匹配总数很多，Lucene的结果集占用的内存空间也不会很多。对于一般的模糊检索应用是用不到这么多的结果的，头100条已经可以满足90%以上的检索需求。

如果首批缓存结果数用完后还要读取更后面的结果时Searcher会再次检索并生成一个上次的搜索缓存数大1倍的缓存，并再重新向后抓取。所以如果构造一个Searcher去查1－120条结果，Searcher其实是进行了2次搜索过程：头100条取完后，缓存结果用完，Searcher重新检索再构造一个200条的结果缓存，依此类推，400条缓存，800条缓存。由于每次Searcher对象消失后，这些缓存也访问那不到了，你有可能想将结果记录缓存下来，缓存数尽量保证在100以下以充分利用首次的结果缓存，不让Lucene浪费多次检索，而且可以分级进行结果缓存。

Lucene的另外一个特点是在收集结果的过程中将匹配度低的结果自动过滤掉了。这也是和数据库应用需要将搜索的结果全部返回不同之处。

我的一些尝试：

• 支持中文的Tokenizer：这里有2个版本，一个是通过JavaCC生成的，对CJK部分按一个字符一个TOKEN索引，另外一个是从SimpleTokenizer改写的，对英文支持数字和字母TOKEN，对中文按迭代索引。
• 基于XML数据源的索引器：XMLIndexer，因此所有数据源只要能够按照DTD转换成指定的XML，就可以用XMLIndxer进行索引了。
• 根据某个字段排序：按记录索引顺序排序结果的搜索器：IndexOrderSearcher，因此如果需要让搜索结果根据某个字段排序，可以让数据源先按某个字段排好序（比如：PriceField），这样索引后，然后在利用这个按记录的ID顺序检索的搜索器，结果就是相当于是那个字段排序的结果了。

从Lucene学到更多

Luene的确是一个面对对象设计的典范

• 所有的问题都通过一个额外抽象层来方便以后的扩展和重用：你可以通过重新实现来达到自己的目的，而对其他模块而不需要；
• 简单的应用入口Searcher, Indexer，并调用底层一系列组件协同的完成搜索任务；
• 所有的对象的任务都非常专一：比如搜索过程：QueryParser分析将查询语句转换成一系列的精确查询的组合(Query),通过底层的索引读取结构IndexReader进行索引的读取，并用相应的打分器给搜索结果进行打分/排序等。所有的功能模块原子化程度非常高，因此可以通过重新实现而不需要修改其他模块。 
• 除了灵活的应用接口设计，Lucene还提供了一些适合大多数应用的语言分析器实现（SimpleAnalyser,StandardAnalyser），这也是新用户能够很快上手的重要原因之一。

这些优点都是非常值得在以后的开发中学习借鉴的。作为一个通用工具包，Lunece的确给予了需要将全文检索功能嵌入到应用中的开发者很多的便利。

此外，通过对Lucene的学习和使用，我也更深刻地理解了为什么很多数据库优化设计中要求，比如：

• 尽可能对字段进行索引来提高查询速度，但过多的索引会对数据库表的更新操作变慢，而对结果过多的排序条件，实际上往往也是性能的杀手之一。
• 很多商业数据库对大批量的数据插入操作会提供一些优化参数，这个作用和索引器的merge_factor的作用是类似的，
• 20%/80%原则：查的结果多并不等于质量好，尤其对于返回结果集很大，如何优化这头几十条结果的质量往往才是最重要的。
• 尽可能让应用从数据库中获得比较小的结果集，因为即使对于大型数据库，对结果集的随机访问也是一个非常消耗资源的操作。
  

参考资料：

Apache: Lucene Project
http://jakarta.apache.org/lucene/
Lucene开发/用户邮件列表归档
Lucene-dev@jakarta.apache.org
Lucene-user@jakarta.apache.org

The Lucene search engine: Powerful, flexible, and free
http://www.javaworld.com/javaworld/jw-09-2000/jw-0915-Lucene_p.html

Lucene Tutorial
http://www.darksleep.com/puff/lucene/lucene.html

Notes on distributed searching with Lucene
http://home.clara.net/markharwood/lucene/

中文语言的切分词
http://www.google.com/search?sourceid=navclient&hl=zh-CN&q=chinese+word+segment

搜索引擎工具介绍
http://searchtools.com/

Lucene作者Cutting的几篇论文和专利
http://lucene.sourceforge.net/publications.html 

Lucene的.NET实现：dotLucene
http://sourceforge.net/projects/dotlucene/

Lucene作者Cutting的另外一个项目：基于Java的搜索引擎Nutch
http://www.nutch.org/   http://sourceforge.net/projects/nutch/

关于基于词表和N-Gram的切分词比较
http://china.nikkeibp.co.jp/cgi-bin/china/news/int/int200302100112.html

2005-01-08 Cutting在Pisa大学做的关于Lucene的讲座：非常详细的Lucene架构解说

XML数据源对象是一个ActiveX控件，允许你在XML文件和HTML页面之间操作数据。本文将向你展示如何从各种XML数据源中提取数据，以及如何使用JavaScript显示这些数据。 

　　XML数据源对象DSO是一个微软ActiveX控件，构建在微软IE4以后的版本上。这个对象允许你把一个外部的XML文件或者嵌入HTML文件中的内容提取到HTML页面中。 

　　你可以在一个Web页面中使用XML - DSO从一个外部XML文件中选取内容，从嵌入Web页面的XML中提取XML数据，然后使用JavaScript操作这些数据。然而，并不建议在Internet中使用这个对象，因为DSO只能工作在MSIE 4以上的浏览器中，因此这可能会带来一些兼容性问题。 所以，在企业内部网使用XML-DSO是很合适的。 

　　开始

　　为了初始化XML - DSO对象，我们使用＜OBJECT＞标记。 用于XML-DSO的CLASSID是：

　　　　CLSID:550dda30-0541-11d2-9ca9-0060b0ec3d39

　　这ID唯一标识XML-DSO。使用下面的代码在一个Web页面中初始化这个控件： 

　　＜OBJECT ID="SomeID" CLASSID="CLSID:550dda30-0541-11d2-9ca9-0060b0ec3d39"＞＜/OBJECT＞

　　虽然大部分对象需要许多参数与之相关联，但是XML-DSO不需要任何参数。 

　　使用一个XML数据岛析取数据

　　首先，通过使用＜XML＞标记包含一个XML数据岛。其次，给它分配一个ID，xmldb --以备以后使用。 数据实际上是使用HTML标记：＜ALT＞，＜SPAN＞，＜DIV＞等等提取的。代码列表1中的代码使用了＜SPAN＞标记。datasrc属性指定了你想从中提取数据的那个数据岛。datafld属性指定了你想要的数据的XML标记。所以，第一个＜SPAN＞提取名称，而第二＜SPAN＞提取性别。 

　　代码列表1：

＜!-- example1.htm --＞
＜html＞
＜head＞
＜title＞XML DSO-example1.htm＜/title＞
＜/head＞
＜body bgcolor="#FFFFFF"＞
＜xml id="xmldb"＞
＜db＞
＜member＞
＜name＞Premshree Pillai＜name＞
＜sex＞male＜/sex＞
＜/member＞
＜member＞
＜name＞Vinod＜/name＞
＜sex＞male＜/sex＞
＜/member＞
＜/db＞
＜/xml＞

＜span datasrc="#xmldb" datafld="name"＜＜/span＞
＜br＞
＜span datasrc="#xmldb" datafld="sex"＞＜/span＞

＜/body＞
＜/html＞  

　　注意这段代码没有初始化一个XML-DSO对象。这是因为XML数据岛的使用中已经隐式地创建了一个。输出应为： 
　　
　　Premshree Pillai
　　male

　　注意在XML数据岛中有两个＜name＞和＜sex＞标记。使用这个方法，你只能提取这些标记中的第一个实例。代码列表2中的代码使用＜TABLE＞标记提取所有的实例： 

　　输出将是: 
　　　 
     Name     Sex 
     -----------------------------------
     Premshree Pillai  male 
     Vinod      male 

　　在代码列表2中，＜TABLE＞标记使用＜TD＞标记内的＜DIV＞标记提取数据。表格将自动重复＜member＞（＜name＞和＜sex＞的母标记）的每个实例。 

　　代码列表2：

＜!-- example2.htm --＞
＜html＞
＜head＞
＜title＞XML DSO-example2.htm＜/title＞
＜/head＞
＜body bgcolor="#FFFFFF"＞

＜xml id="xmldb"＞
＜db＞
＜member＞
＜name＞Premshree Pillai＜name＞
＜sex＞male＜/sex＞
＜/member＞
＜member＞
＜name＞Vinod＜/name＞
＜sex＞male＜/sex＞
＜/member＞
＜/db＞
＜/xml＞

＜table datasrc="#xmldb" border="1"＞
＜thead＞
＜th＞Name＜/th＞
＜th＞Sex＜/th＞
＜/thead＞
＜tr＞
＜td＞＜div datafld="name"＞＜/div＞＜/td＞
＜td＞＜div datafld="sex"＞＜/div＞＜/td＞
＜/tr＞
＜/table＞
＜/body＞
＜/html＞

使用外部XML文件提取数据

　　为了使用XML-DSO加载一个外部XML文件，你必须显式的包含这个对象并且使用一些JavaScript。 

　　首先创建一个XML-DSO对象，使用ID myXML。添加宽度和高度属性到＜OBJECT＞标记中，然后设置它们的值为0。这保证XML-DSO对象不会占据你的Web页面的任何空间。 

　　其次，使用datasrc创建一个象myXML一样的表--类似于代码列表2中一样。代码使用＜DIV＞标记（在TD标记之）提取数据，使用datafld作为第一栏的信息，并且使用URL作为第二栏。添加＜SCRIPT＞标记，因为在这里，外部的XML使用Java脚本显式地声明你想要加载的XML文件。 

　　设置变量xmlDso为myXML.XMLDocument。myXML引用你已经创建的对象。接下来，使用XML-DSO的load()方法加载example3.xml。文件example3.xml连接到对象myXML上。 

＜!-- example3.xml --＞
＜?xml version="1.0" ?＞
＜ticker＞
＜item＞
＜message＞JavaScript Ticker using XML DSO＜/message＞
＜URL＞http://someURL.com＜/URL＞
＜/item＞
＜/ticker＞ 

　　现在，研究一下下面的HTML页面: 

＜!-- example3.htm --＞
＜html＞
＜head＞
＜title＞XML DSO-example3.htm＜/title＞
＜script language="JavaScript"＞
function load() {
var xmlDso=myXML.XMLDocument;
xmlDso.load("example3.xml");
}
＜/script＞
＜/head＞
＜body bgcolor="#FFFFFF" onLoad="load()"＞

＜object id="myXML" CLASSID="clsid:550dda30-0541-11d2-9ca9-0060b0ec3d39" 
width="0" height="0"＞＜/object＞

＜table datasrc="#myXML" border="1"＞
＜thead＞
＜th＞Message＜/th＞
＜th＞URL＜/th＞
＜/thead＞
＜tr＞
＜td＞＜div datafld="message"＞＜/div＞＜/td＞
＜td＞＜div datafld="URL"＞＜/div＞＜/td＞
＜/tr＞
＜/table＞

＜/body＞
＜/html＞ 

　　输出应是: 

　　　Message URL
　　　JavaScript Ticker using XML DSO http://someURL.com

　　上面的脚本非常特殊化。下面给出一个更一般的脚本： 

＜script language="JavaScript"＞
var xmlDso;
function load(xmlFile, objName) {
eval('xmlDso='+objName+'.XMLDocument');
xmlDso.load(xmlFile);
}
＜/script＞
Now, to load any XML file use: 
load("SomeXMLFile.xml","anyXmlDsoObject");

使用XML-DSO和JavaScript

　　假设你有一个包含姓名、电子邮件地址和电话号码的XML文件。你想使用它构建一个应用程序，显示每个人的档案--一次显示一个。用户将使用"Next"和"Previous"按钮浏览每个人的数据。Javascript可以帮助你实现这个目的。 

　　下面的代码使用记录集方法把文件中所有的数据保存到一个变量memberSet中。moveNext()方法指向下一个数据项（下一行）。脚本然后载入XML文件example4.xml，把记录保存到变量memberSet中。第一个记录将被显示，但是memberSet.moveNext()指向文件中相对于前一个指定数据的下一个记录。 

＜!-- example4.xml --＞
＜?xml version="1.0" ?＞
＜myDB＞
＜member＞
＜name＞Premshree Pillai＜/name＞
＜sex＞male＜/sex＞
＜/member＞
＜member＞
＜name＞Vinod＜/name＞
＜sex＞male＜/sex＞
＜/member＞
＜member＞
＜name＞Santhosh＜/name＞
＜sex＞male＜/sex＞
＜/member＞
＜/myDB＞ 

　　这里是相应的HTML文件： 

＜!-- example4.htm --＞
＜html＞
＜head＞
＜title＞XML DSO-example4.htm＜/title＞
＜script language="JavaScript"＞
function load() {
var xmlDso=myDB.XMLDocument;
xmlDso.load("example4.xml");

/* Get the complete record set */
var memberSet=myDB.recordset;

/* Go to next data */
memberSet.moveNext();
}
＜/script＞
＜/head＞
＜body bgcolor="#FFFFFF" onLoad="load()"＞

＜object id="myDB" CLASSID="clsid:550dda30-0541-11d2-9ca9-0060b0ec3d39" 
width="0" height="0"＞＜/object＞

＜span datasrc="#myDB" datafld="name"＞＜/span＞

＜/body＞
＜/html＞ 

　　输出应是: 

　　　Vinod

　　下面给出更多使用JavaScript操作XML-DSO的方法： 

　　　· movePrevious(): 指向前一个数据项。 

　　　· moveFirst(): 指向第一个数据项。 

　　　· moveLast(): 指向最后一个数据项。 

　　　· EOF: 这个属性用来检测我们是否已经到达数据记录的底部。
使用XML-DSO和JavaScript

　　假设你有一个包含姓名、电子邮件地址和电话号码的XML文件。你想使用它构建一个应用程序，显示每个人的档案--一次显示一个。用户将使用"Next"和"Previous"按钮浏览每个人的数据。Javascript可以帮助你实现这个目的。 

　　下面的代码使用记录集方法把文件中所有的数据保存到一个变量memberSet中。moveNext()方法指向下一个数据项（下一行）。脚本然后载入XML文件example4.xml，把记录保存到变量memberSet中。第一个记录将被显示，但是memberSet.moveNext()指向文件中相对于前一个指定数据的下一个记录。 

＜!-- example4.xml --＞
＜?xml version="1.0" ?＞
＜myDB＞
＜member＞
＜name＞Premshree Pillai＜/name＞
＜sex＞male＜/sex＞
＜/member＞
＜member＞
＜name＞Vinod＜/name＞
＜sex＞male＜/sex＞
＜/member＞
＜member＞
＜name＞Santhosh＜/name＞
＜sex＞male＜/sex＞
＜/member＞
＜/myDB＞  

　　这里是相应的HTML文件： 

＜!-- example4.htm --＞
＜html＞
＜head＞
＜title＞XML DSO-example4.htm＜/title＞
＜script language="JavaScript"＞
function load() {
var xmlDso=myDB.XMLDocument;
xmlDso.load("example4.xml");

/* Get the complete record set */
var memberSet=myDB.recordset;

/* Go to next data */
memberSet.moveNext();
}
＜/script＞
＜/head＞
＜body bgcolor="#FFFFFF" onLoad="load()"＞

＜object id="myDB" CLASSID="clsid:550dda30-0541-11d2-9ca9-0060b0ec3d39" 
width="0" height="0"＞＜/object＞

＜span datasrc="#myDB" datafld="name"＞＜/span＞

＜/body＞
＜/html＞ 

　　输出应是: 

　　　Vinod

　　下面给出更多使用JavaScript操作XML-DSO的方法： 

　　　· movePrevious(): 指向前一个数据项。 

　　　· moveFirst(): 指向第一个数据项。 

　　　· moveLast(): 指向最后一个数据项。 

　　　· EOF: 这个属性用来检测我们是否已经到达数据记录的底部。 

　　initTicker()首先检查是否有IE 4+。如果浏览器是IE4+，这个XML文件被作为一个参数被传递并载入。如果定时器失败了，那么调用xmlDsoTicker()函数。xmlDsoTicker()除了xmlFile参数以外，和initTicker()有相同的参数，因为XML文件已经被载入。xmlDsoTicker()检查变量counter（初始值为maxMsgs）是否小于maxMsgs-1。如果是，moveNext()方法指向tickerSet中下一个数据项。 

　　HTML页面的BODY包含下面的代码： 

＜a href="" datasrc="#ticker" datafld="URL" class="tickerStyle"＞
＜span datasrc="#ticker" datafld="message"＞＜/span＞
＜/a＞ 

1、首先，我们在机器里新建一个用户名为text（这里任意的用户名都可以）。

2、注销Administrator用户。改用text用户进入系统。

3、点击“开始”—“运行”。键入regedit。可以打开注册表编辑器。

4、 找到以下路径：HKEY_CURRENT_USER\\Software\\Microsoft\\Internet Explorer。选中“Internet Explorer”。点击表单栏的“注册表”。导出注册表文件。

5、这时就把text用户下的IE设置给导出来了。因为text用户是新加入的。所以他的IE设置并没有被更改过。

6、现在我们切换回Administrator用户登录系统。

7、点击“打开”—“运行”。键入regedit。依然进入注册表编辑器。

8、点击表单栏的“注册表”，导入注册表。把刚才保存的那个注册表文件导入进去就可以了。

现在我们再打开IE。发现一切都已经恢复成系统默认的样子了。

经实验本方法非常实用。为了安全起见，大家还需要进行必要的杀毒等措施。

        定义：
          将常用的或很复杂的工作，预先用SQL语句写好并用一个指定的名称存储起来,   那么以后要叫数据库提供与已定义好的存储过程的功能相同的服务时,只需调用execute,即可自动完成命令。
        讲到这里,可能有人要问：这么说存储过程就是一堆SQL语句而已啊？
          Microsoft公司为什么还要添加这个技术呢?
        那么存储过程与一般的SQL语句有什么区别呢?
        存储过程的优点：
          1.存储过程只在创造时进行编译，以后每次执行存储过程都不需再重新编译，而一般SQL语句每执行一次就编译一次,所以使用存储过程可提高数据库执行速度。
          2.当对数据库进行复杂操作时(如对多个表进行Update,Insert,Query,Delete时），可将此复杂操作用存储过程封装起来与数据库提供的事务处理结合一起使用。
          3.存储过程可以重复使用,可减少数据库开发人员的工作量
          4.安全性高,可设定只有某此用户才具有对指定存储过程的使用权
        存储过程的种类：
          1.系统存储过程：以sp_开头,用来进行系统的各项设定.取得信息.相关管理工作,
          如   sp_help就是取得指定对象的相关信息
          2.扩展存储过程   以XP_开头,用来调用操作系统提供的功能
          exec   master..xp_cmdshell   'ping   10.8.16.1'
          3.用户自定义的存储过程,这是我们所指的存储过程
          常用格式
          Create   procedure   procedue_name
          [@parameter   data_type][output]
          [with]{recompile|encryption}
          as
          sql_statement
        解释:  
        output：表示此参数是可传回的
        with   {recompile|encryption}
        recompile:表示每次执行此存储过程时都重新编译一次
        encryption:所创建的存储过程的内容会被加密
        如:
          表book的内容如下
          编号   书名   价格
          001   C语言入门   $30
          002   PowerBuilder报表开发   $52
          实例1:查询表Book的内容的存储过程
          create   proc   query_book
          as  
          select   *   from   book
          go
          exec   query_book
          实例2:加入一笔记录到表book,并查询此表中所有书籍的总金额
          Create   proc   insert_book
          @param1   char(10),@param2   varchar(20),@param3   money,@param4   money   output
          with   encryption   ---------加密
          as
          insert   book(编号,书名，价格）   Values(@param1,@param2,@param3)
          select   @param4=sum(价格)   from   book
          go
          执行例子:  
          declare   @total_price   money  
          exec   insert_book   '003','Delphi   控件开发指南',$100,@total_price
          print   '总金额为'+convert(varchar,@total_price)
          go
        存储过程的3种传回值:
          1.以Return传回整数
          2.以output格式传回参数
          3.Recordset
        传回值的区别:
          output和return都可在批次程式中用变量接收,而recordset则传回到执行批次的客户端中  
        实例3：设有两个表为Product,Order,其表内容如下：
          Product
          产品编号   产品名称   客户订数  
          001   钢笔   30  
          002   毛笔   50  
          003   铅笔   100  
          Order  
          产品编号   客户名   客户订金
          001   南山区   $30
          002   罗湖区   $50
          003   宝安区   $4
        请实现按编号为连接条件,将两个表连接成一个临时表,该表只含编号.产品名.客户名.订金.总金额,
        总金额=订金*订数,临时表放在存储过程中
        代码如下:
          Create   proc   temp_sale
          as
          select   a.产品编号,a.产品名称,b.客户名,b.客户订金,a.客户订数*   b.客户订金   as总金额
          into   #temptable   from   Product   a   inner   join   Order   b   on   a.产品编号=b.产品编号
          if   @@error=0  
          print   'Good'
          else
        &n bsp; print   'Fail'
          go

存储过程介绍  
一、先介绍一下什么是存储过程  
存储过程是利用SQL   Server所提供的Tranact-SQL语言所编写的程序。Tranact-SQL语言是SQL   Server提供专为设计数据库应用程序的语言，它是应用程序和SQL   Server数据库间的主要程序式设计界面。它好比Oracle数据库系统中的Pro-SQL和Informix的数据库系统能够中的Informix-4GL语言一样。这类语言主要提供以下功能，让用户可以设计出符合引用需求的程序：  
1)、变量说明  
2)、ANSI兼容的SQL命令(如Select,Update….)  
3)、一般流程控制命令(if…else…、while….)  
4)、内部函数  

二、存储过程的书写格  

CREATE   PROCEDURE   [拥有者.]存储过程名[;程序编号]  
[(参数#1,…参数#1024)]  
[WITH  
{RECOMPILE   |   ENCRYPTION   |   RECOMPILE,   ENCRYPTION}  
]  
[FOR   REPLICATION]  
AS   程序行  

其中存储过程名不能超过128个字。每个存储过程中最多设定1024个参数  
(SQL   Server   7.0以上版本),参数的使用方法如下:  

@参数名   数据类型   [VARYING]   [=内定值]   [OUTPUT]  

每个参数名前要有一个“@”符号,每一个存储过程的参数仅为该程序内部使用,参数的类型除了IMAGE外，其他SQL   Server所支持的数据类型都可使用。  
[=内定值]相当于我们在建立数据库时设定一个字段的默认值，这里是为这个参数设定默认值。[OUTPUT]是用来指定该参数是既有输入又有输出值的，也就是在调用了这个存储过程时，如果所指定的参数值是我们需要输入的参数，同时也需要在结果中输出的，则该项必须为OUTPUT，而如果只是做输出参数用，可以用CURSOR，同时在使用该参数时，必须指定VARYING和OUTPUT这两个语句。  

例子:  
CREATE   PROCEDURE   order_tot_amt   @o_id   int,@p_tot   int   output   AS  
SELECT   @p_tot   =   sum(Unitprice*Quantity)  
FROM   orderdetails  
WHERE   ordered=@o_id  

例子说明:  
该例子是建立一个简单的存储过程order_tot_amt,这个存储过程根据用户输入的定单ID号码(@o_id),由定单明细表(orderdetails)中计算该定单销售总额[单价(Unitprice)*数量(Quantity)],这一金额通过@p_tot这一参数输出给调用这一存储过程的程序  

三、在SQL   Server中执行存储过程  

在SQL   Server的查询分析器中，输入以下代码:  
declare   @tot_amt   int  
execute   order_tot_amt   1,@tot_amt   output  
select   @tot_amt  

以上代码是执行order_tot_amt这一存储过程，以计算出定单编号为1的定单销售金额，我们定义@tot_amt为输出参数，用来承接我们所要的结果