有话就说: Blog

空杯心态

Tue, 05 Aug 2008 13:56:22 GMT

敬畏是智慧的开端

自由的前提是自律

昨日之非不可留，今日之是不可执

只管走过去，不要逗留去采了花朵去保留，因为一路上，还会有鲜花开放

不要因为因为一朵花而牺牲了整个春天

大智知止，小智惟谋

将自己一放小，世界就变大

越丰满的稻穗，头垂得越低

一个优秀的人，一定要懂得时刻弯腰，这样才能看清脚下的路

君子不器：君子不是器具，要具体问题具体分析

毋意：不要妄加揣测

毋必：不要妄下断语

毋固：不将事情的看法固化

毋我：不将自己的个人认知、意志高于一切

退步原来是向前

六根清净：眼、耳、鼻、舌、身、意六根，去掉不应该有的贪婪和执著，这样生命才会海阔天空

回头即彼岸，人一直向前，不断超越；其实回头，回到生命的根本，就是彼岸

空心就是无执著的心，是自由的心，是新鲜的心，是创造的心。就是对特定东西无执著的心。

在向心事物挑战时，最初要有敢于行的气概，其次要有贯彻行的努力，然后不久就变成习惯行了

ajax dwr的应用

Mon, 04 Aug 2008 08:17:39 GMT

DWR是apache下面的一个ajax的一个项目，dwr的功能是在js中调用java的类方法。

1.从http://directwebremoting.org/下载dwr.jar，引入项目

2.配置web.xml和dwr.xml

3.在调用页面上引用下面js。注意不用实际引用文件，只需写明引用就可。

4.编写java后台调用类方法

5.调用类返回后执行js的回调方法

如：Demo.sayHello(name, backA); //backA是回调方法

  function backA(data) {  //java类方法sayHello回调函数
   dwr.util.setValue("demoReply", data);
  }

6.在js调用java类方法时，可以传递pojo类。通过dws.xml的convert 标签配置，将前台js pojo传递给java后台pojo。
如： dwr.xml 的 <convert match="org.getahead.dwrdemo.simpletext.Person" converter="bean"/>

var person = { name:'zhangxin', age:33, sex:1 };

Demo.sayPerson(person, backB);

web.xml配置如下：

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4"
xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

<servlet>
<servlet-name>dwr-invoker</servlet-name>
<servlet-class>org.directwebremoting.servlet.DwrServlet</servlet-class>
<init-param>
     <param-name>debug</param-name>
     <param-value>true</param-value>
</init-param>
</servlet>

<servlet-mapping>
<servlet-name>dwr-invoker</servlet-name>
<url-pattern>/dwr/*</url-pattern>
</servlet-mapping>
</web-app>

dwr.xml配置如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE dwr PUBLIC
"-//GetAhead Limited//DTD Direct Web Remoting 2.0//EN"
"http://getahead.org/dwr/dwr20.dtd">

<dwr>
<allow>
    <create creator="new" javascript="Demo">
      <param name="class" value="org.getahead.dwrdemo.simpletext.Demo"/>
    </create>
    <convert match="org.getahead.dwrdemo.simpletext.Person" converter="bean"/>  //将前台的js pojo转换成java类pojo
</allow>
</dwr>

my.html代码如下：

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
    <title>MyHtml.html</title>
    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    <meta http-equiv="description" content="this is my page">
    <meta http-equiv="content-type" content="text/html; charset=UTF-8">
    
<script type="text/javascript" src='./dwr/interface/Demo.js'></script> 关键配置
<script type="text/javascript" src="./dwr/engine.js"></script>
<script type="text/javascript" src="./dwr/util.js" ></script>

  function backB(data) {  //java类方法sayPerson回调函数
   dwr.util.setValue("demoReply1", data);
  }
</script>
</head>
<body>
<p>
Name:
<input type="text" id="demoName"/>
<input value="Send" type="button" onclick="update()"/>
<br/>
Reply: <span id="demoReply"></span>
</p>

</body>
</html>

Demo.java代码如下：

package org.getahead.dwrdemo.simpletext;

import org.getahead.dwrdemo.simpletext.Person;

public class Demo {
    public String sayHello(String name) {
        return "Hi , " + name;
    }
    public String sayPerson(Person person) {
        String ss = "hello , " + person.getName() + "," + person.getAge() + "," +person.getSex();
        System.out.println(ss);
        return ss;
    }
}

person.java代码如下：

package org.getahead.dwrdemo.simpletext;

public class Person {
private String name;
private int age;
private int sex;

public String getName() {
  return name;
}
public int getAge() {
  return age;
}
public int getSex() {
  return sex;
}
public void setName(String pname) {
  name = pname;
}
public void setAge(int page) {
  age = page;
}
public void setName(int psex) {
  sex = psex;
}
}

官方例子： http://directwebremoting.org/dwr/examples/text

团队建设

Wed, 30 Jul 2008 00:42:59 GMT

测评维度	序号	题目	二级维度
工作效率	1	公司的使命/目标使我觉得我的工作很重要	战略传承
	2	在过去7天里，我有机会了解公司内发生的最新发展情况	战略传承
	3	我觉得公司的政策和工作流程清晰明了	工作流程
	4	我所在团队里，组织井然有序，运作效率令人满意
	5	我所在团队里，分工明确，每个人都知道做什么
团队建设	6	在工作中，我每天都有机会做我最擅长做的事	分工与目标设定
	7	我的上级为我设定了挑战性的目标
	8	我的上级特别注重提高工作要求
	9	我的上级不能容忍平庸的绩效表现	激励团队
	10	在过去7天里，我得到的支持和鼓励多于批评
	11	我觉得我的上级关心我的个人情况
	12	在工作中，我觉得我的意见受到重视
	13	我觉得我的上级鼓励我冒合理的风险	授权
	14	我的上级鼓励我按照自己认为最合适的方法来工作
	15	我的上级确保下属们能积极参与计划的制定、实施及跟进
	16	我的同事们致力于高质量的工作	团队归属
	17	我在工作单位有一个最要好的朋友
	18	在紧急情况下，我的同事们都愿意分担他人的职责
	19	我愿意推荐我的朋友到本单位工作
学习发展	20	在过去的六个月内，我的上级主动跟我沟通学习和发展机会	学习发展
	21	在过去一年里，我有机会参加有针对性的培训或学习交流
	22	在过去一年里，我能得到提升自己职业发展所需要的锻炼机会
离职预警	23	我在未来6个月内可能寻找其他公司的工作（反向计分）	离职预警

学习巴菲特投资

Sat, 26 Jul 2008 10:57:36 GMT

一家公司的一流业务的第一条标准是这家公司有没有强大的竞争优势，以及这多久种竞争优势能够。这家公司的产品是不是人人想要；产品是不是人人只要。人人只要的产品具有无可替代性。

一家公司的一流业务的第二条标准是老牌。老牌公司长期经营稳定的投资回报。

一家公司的一流业务的第二条标准是大牌。大牌就是市场份额长期占有绝对优势。

购买股票就是购买公司，要关注公司的运营。要与市场隔绝，静下心来，不看价格看价值；不看股价看公司；购买被低估的股票，等到价值回归时获得收益；

JMX应用

Wed, 23 Jul 2008 10:05:41 GMT

JMX是Java Management Extension的缩写，可译为Java管理工具扩展，扩展的意思就是JMX不包含在标准的J2SE中，我们必须要另外下载JMX RI的实现。不过，这种把JMX排除在J2SE之外的情况已经成为历史了，J2SE5.0和J2SE6.0都已经包含了JMX的标准实现。这说明， JMX已经成为J2SE不可分割的一部分，另外一方面，JMX已经成为Java平台上管理工具的事实标准，在业界广泛使用。例如，JBOSS就是以JMX为微内核，Web应用模块和其它功能模块都可热插拨到这个微内核，将JMX的管理功能发挥得淋漓尽致。

JMX要管理的对象是什么呢，是资源。什么是资源，资源是指企业中的的各种应用软件和平台，举例来说，一个公司内部可能有许多应用服务器、若干Web服务器、一台至多台的数据库服务器及文件服务器等等，那么，如果我们想监视数据库服务器的内存使用情况，或者我们想更改应用服务器上JDBC最大连接池的数目，但我们又不想重启数据库和应用服务器，这就是典型意义上的资源管理，即对我们的资源进行监视(Monitoring，查看)和管理(Management，更改)，这种监视和更改不妨碍当前资源的正常运行。对资源进行适当的监测和管理，可以让我们的IT资源尽可能的平稳运行，可以为我们的客户提供真正意思上的24×7服务。在资源耗尽或者在硬件出故障之前，我们就可以通过管理工具监测到，并通过管理工具进行热调整和插拔。独孤九剑，料敌机先，适当的资源管理就是我们料敌机先的工具，可以让我们立于IT服务的不败之地。在Sun公司提出JMX(JSR174)以前，人们通常都是使用SNMP对网络上的资源进行管理。SNMP的主要问题是入门门槛太高，不容易使用。所以Sun提出了JSR174倡议并且提供了一套JMX的参考实现。

从技术上说，JMX整体架构可分为三层，即资源植入层(Instrumentation Level，可能有更好的译法？)、代理层(Agent Level)和管理层(Manager Level)，简述如下：

    资源植入层(Instrumentation Level)：该层包含MBeans及这些MBeans所管理的资源，MBeans是一个Java对象，它必须实现JMX规范中规定的接口。按照JMX规范，在MBeans对象的接口中，我们可以指定管理层可以访问资源的哪些属性，可以调用资源的哪些方法，并且，在资源的属性发生变化是，我们的MBeans可以发出消息，通知对这些属性变化感兴趣的其它对象。JMX规范定义了四种MBeans，它们分别是标准MBeans(Standard MBeans)、动态MBeans(Dynamic MBeans)、开放MBeans(Open MBeans)和模态MBeans(Model MBeans)。

    代理层(Agent Level)：代理层的目的就是要把MBeans中实现的接口暴露给管理层，该层通常由MBean Server和Agent Services构成，MBean Server就是一个MBeans对象注册器，所有的资源MBeans都注册到这个MBean Server，对象管理器或者其它的管理层应用程序可以通过访问MBean Server，从而可以访问MBean Server中注册的MBeans，当然也就可以监视和管理和这些MBeans绑定的资源。

    管理层(Manager Level)：又称之为分布式服务层(Distributed Services)，顾名思义，该层主要包含一些管理应用程序，这些程序可以访问和操作JMX代理层(Agent Level)。这些管理应用程序可以是一个Web应用，也可能是一个Java SWT应用程序。

下面，我们举一个简单的例子，理解一下JMX中中的各个概念。我们家有一个中央热水系统(Central Heater System)，它是我们家的一个资源，现在我们想通过JMI进行管理。现有的代码如下所示：

1.1资源植入层(Instrumentation Level)代码示例
我们如何让JMX对我们的中央热水器进行管理呢?首先，我们并不想让远程管理者能够关闭我们的中央热水器，因为热水器一旦关上，我们再也无法访问厂家提供的API。既然不能关闭它，我们的MBeans中也就不需要打开(turnOn)方法。所以，我们简单定义的MBeans接口如下：
package carl.test.jmx;
public interface CentralHeaterImplMBean {
public String getHeaterProvider();
public int getCurrentTemperature();
public void setCurrentTemperature(int newTemperature);
public String printCurrentTemperature();
}

上面的MBean接口及其简单，意义也非常明显，我们只向管理程序公开热水器的生产厂家(该属性为只读，管理程序不能更改热水器的生产厂家)，但管理程序可以获取并更改当前热水器的温度，并且可以打印出热水器的当前温度。
接下来，我们要做的，就是更改我们已有的CentralHeaterImpl.java代码，让它实现CentralHeaterImplMBean接口，同时实现CentralHeaterImplMBean MBean中规定的所有方法。CentralHeaterImpl.java更改后的源代码如下：

package carl.test.jmx;
public class CentralHeaterImpl implements CentralHeaterInf,CentralHeaterImplMBean {
int currentTemperature;
public int getCurrentTemperature() {
return currentTemperature;
}
public void setCurrentTemperature(int newTemperature) {
currentTemperature=newTemperature;
}
public void turnOff() {
System.out.println("The heater is off. ");
}
public void turnOn() {
System.out.println("The heater is on. ");

}
public String getHeaterProvider() {
return HEATER_PROVIDER;
}
public String printCurrentTemperature() {
String printMsg="Current temperature is:"+currentTemperature;
System.out.println(printMsg);
return printMsg;
}
}
到此为止，我们的资源植入层(Instrumentation Level)的代码全部完成，它主要由一个MBean(CentralHeaterImplBean)及其实现类CentralHeaterImpl组成，在CentralHeaterImplBean这个MBean接口中，我们说明了要向管理程序暴露的属性和方法，在本例中，我们的管理程序可以访问热水器的生产厂家信息，同时还可以获取和设置并打印热水器的温度。在MBean的实现类中，我们实现了MBean接口中规定的所有方法。

1.2 代理层(Agent Level)示例代码

import java.lang.management.ManagementFactory;
import javax.management.MBeanServer;
import javax.management.ObjectName;

public class CentralHeaterAgent {
private static MBeanServer mBeanServer;
public static void main(String[] args) throws Exception {
    ObjectName oname;
    mBeanServer = ManagementFactory.getPlatformMBeanServer();
    CentralHeaterInf centralHeater = new CentralHeaterImpl();
    oname = new ObjectName("MyHome:name=centralheater");
    mBeanServer.registerMBean(centralHeater, oname);
    System.out.println("Press any key to end our JMX agent...");
System.in.read();
}
}
您可以看到，上面的代理层代码异常简单。前面讲过，代理层中最重要的对象就是MBeanServer，我们可以把MBeanServer理解为一个全局的HashMap，所有的MBeans都通过唯一的名字注册到这个HashMap，这个HashMap可以跨越JVM访问，甚至可以通过RMI、Http及其它手段跨越网络传输到其它机器，让其它机器也能访问这个MBeanServer中注册的对象。下面我们稍微理解一下代理层代码，在main()方法中，

a) 首先我们从ManagementFactory的工厂方法中获得MBeanServer对象；
b) 然后实例化我们的热水器对象，注意这个对象声明为CentralHeaterInf，而不是CentralHeaterImplMBean。JMX规范并没有规定对象声明，只要这个对象实现了一个以SomethingMBean命名的接口或父类即可；
c) 接下来通过new ObjectName(String)构造函数给我们的MBean一个全局的名字，这个名字一般的格式是：”域名:属性1=*,属性2=*,…”构成；
d) 第四步，我们调用MBeanServer的regiesterBean方法，通过第三步声明的全局名字把我们的MBean实例注册到MBeanServer。
这几步都非常简单明了。下面我们在Eclipse中运行代理层代码，运行时，请加上下面几个JVM运行时参数：

-Dcom.sun.management.jmxremote
-Dcom.sun.management.jmxremote.port=9999
-Dcom.sun.management.jmxremote.ssl="false"
-Dcom.sun.management.jmxremote.authenticate="false"

这四个JVM运行时参数的意义是，MBeanServer允许其它管理程序通过RMI方式访问，RMI端口是9999，RMI不使用SSL协议，也不需要验证。

1.3 管理层代码

管理层代码编写起来其实也比较简单，但如果您要求界面比较完美，并且您也不想卷入到AWT加Swing的面条代码中，您最好直接使用JDK自带的JConsole.exe程序，这个程序位于JDK\bin目录下，可直接运行。下面我们观察管理程序在远程和本地运行情况。

a) 远程运行JConsole管理程序

请双击JConsole.exe或者通过命令行在本机上启动JConsole.exe，在JConsole的连接界面，选择远程连接，然后输入RMI地址和端口号，本例为localhost:9999，注

意确保我们上面编写的CentralHeaterAgent代理处于运行状态.

连接成功后，请点击MBean标签，并展开MyHome节点，我们可以观察到CentralHeaterImplMBean中暴露给管理程序所有的属性和方法.

我们在CentralHeaterImplMBean接口中规定，CurrentTemperature属性是可以更改的，所以上图中CurrentTemperature的值显示为绿色，表示远程管理者可以调节；但HeaterProvider(生产厂家)的属性是不能更改的，所以其值显示为灰色。现在，我们以远程管理用户的身份，把CurrentTemperature属性的值改为25，并按回车或者点击刷新按钮，接下来您可以在上面的界面中，调用操作方法printCurrentTemperature()，您会在弹出的对话框中看到“Current temperature is:25”的字样，这说明我们的温度更改成功。请注意这是通过远程RMI完成的。

模型驱动架构MDA

Wed, 23 Jul 2008 07:21:16 GMT

MDA是由OMG（Object Management Group，对象管理组织）于2001年提出来的。其核心思想是抽象出与实现技术无关、完整描述业务功能的核心平台无关模型（PIM，Platform Independent Model），然后针对不同实现技术制定多个转换规则，通过这些转换规则及辅助工具将 PIM 转换成与具体实现技术相关的平台相关模型（PSM，Platform Specific Model），最后将经过充实的 PSM 转换成代码。通过PIM和PSM，MDA的目的是分离业务建模与底层平台技术，以保护建模的成果不受技术变迁的影响。
MDA的核心技术：MOF（Meta Object Facility，元对象设施）、CWM（Common Warehouse Metamodel，公共数据仓库元模型）和UML。MDA的主要工作就是要把基于这些技术建立的PIM转换到不同的中间件平台上，得到对应的PSM。技术平台上给出的是目前主要针对的实现平台：CORBA、XML、JAVA、Web Services和.NET。显然，随着技术的发展，这个列表将不断扩充。

MDA提供了一个中立于各开发商的开放的方法，以应对业务和技术变化带来的挑战。基于OMG制定的各项标准，MDA将业务和应用逻辑与底层平台技术分离开来。通过使用UML以及其他的OMG建模标准，来表达应用程序或者集成系统的业务功能和行为，得到的平台无关模型可以通过MDA实现到各种平台上的，如Web Services、.NET、CORBA、J2EE等。这些平台无关模型将应用的业务功能与行为同实现它们的技术特定的代码分离开来。随技术一起的，是为支持跨越不同平台的交互性而带来的无情的繁杂循环，MDA将应用的核心从他们的魔爪中保护出来。（在MDA的工作方式下，）不管应用了哪种具体的技术平台，系统的业务部分和技术部分都可以各自演进（而互不影响）-业务逻辑随业务需求的变化而改变，如果业务有需要的话，技术部分也可以随时享受到新的技术发展带来的好处。

模板引擎 Velocity

Wed, 23 Jul 2008 04:49:10 GMT

模板引擎的设计思想最早由Webmacro提出，并被应用在一个著名的搜索引擎www.altavista.com上。后来，这种思想渐渐被Apache开发小组所采用，并作为一个子项目被提出来，这就是现在的Velocity。

Velocity 是一种通用的、开放源代码的模板解决方案，在 MVC 模型框架中作为视图组件。
Velocity 为 JSP 技术提供了一种可行的替代方案，可以强制实施表示逻辑与应用程序业务逻辑的清晰划分。jsp的MVC方案是structs和标签。
Velocity 是使用VTL模板语言来实现视图表现层部分，使用VTL的简单脚本语言替代JSP语法。

Velocity 解决了如何在 Servlet 和网页之间传递数据的问题，当然这种传输数据的机制是在 MVC 模式上进行的，也就是View 和 Modle , Controller 之间相互独立工作，一方的修改不影响其他方变动，他们之间是通过环境变量（Context）来实现的，当然双方网页制作一方和后台程序一方要相互约定好对所传递变量的命名约定，比如上个程序例子中的 site, name 变量，它们在网页上就是 $name ,$site 。这样只要双方约定好了变量名字，那么双方就可以独立工作了。无论页面如何变化，只要变量名不变，那么后台程序就无需改动，前台网页也可以任意由网页制作人员修改。这就是 Velocity 的工作原理。

　　你会发现简单变量名通常无法满足网页制作显示数据的需要，比如我们经常会循环显示一些数据集，或者是根据一些数据的值来决定如何显示下一步的数据， Velocity 同样提供了循环，判断的简单语法以满足网页制作的需要。Velocity 提供了一个简单的模板语言以供前端网页制作人员使用，这个模板语言足够简单（大部分懂得 javascript 的人就可以很快掌握，其实它比 javascript 要简单的多），当然这种简单是刻意的，因为它不需要它什么都能做， View 层其实不应该包含更多的逻辑，Velocity 的简单模板语法可以满足你所有对页面显示逻辑的需要，这通常已经足够了，jsp 能做很多事情，Sun 在制定 Jsp 1.0 标准的时候，没有及时的限定程序员在 jsp 插入代码逻辑，使得早期的jsp 代码更象是 php 代码，它虽然强大，但是对显示层逻辑来说，并不必要，而且会使 MVC 三层的逻辑结构发生混淆。

Velocity 的问题是开发人员或者页面制作人员必须熟悉VTL语法来维护vm文件，这相当于开发人员或页面人员需要再掌握一套脚本语言，这或许是开发中的一个障碍。毕竟熟悉jsp java语言的人会更多更普遍，多掌握一门语法简单的语言也许会成为快速web开发的一个障碍。

hellosite.vm
Hello $name! Welcome to $site world!

HelloWorld.java
import java.io.StringWriter;
import org.apache.velocity.app.VelocityEngine;
import org.apache.velocity.Template;
import org.apache.velocity.VelocityContext;

public class HelloWorld
{
public static void main( String[] args )
throws Exception
{
 VelocityEngine ve = new VelocityEngine();
 ve.init();
 Template t = ve.getTemplate( "hellosite.vm" );
 VelocityContext context = new VelocityContext();
 context.put("name", "Eiffel Qiu");
 context.put("site", http://www.eiffelqiu.com);
 StringWriter writer = new StringWriter();
 t.merge( context, writer );
 System.out.println( writer.toString() ); 
 }
}

Lucene 索引及搜索简介

Thu, 17 Jul 2008 07:35:38 GMT

Lucene 简介

Lucene 是一个基于 Java 的全文信息检索工具包，它不是一个完整的搜索应用程序，而是为你的应用程序提供索引和搜索功能。Lucene 目前是 Apache Jakarta 家族中的一个开源项目。也是目前最为流行的基于 Java 开源全文检索工具包。

目前已经有很多应用程序的搜索功能是基于 Lucene 的，比如 Eclipse 的帮助系统的搜索功能。Lucene 能够为文本类型的数据建立索引，所以你只要能把你要索引的数据格式转化的文本的，Lucene 就能对你的文档进行索引和搜索。比如你要对一些 HTML 文档，PDF 文档进行索引的话你就首先需要把 HTML 文档和 PDF 文档转化成文本格式的，然后将转化后的内容交给 Lucene 进行索引，然后把创建好的索引文件保存到磁盘或者内存中，最后根据用户输入的查询条件在索引文件上进行查询。不指定要索引的文档的格式也使 Lucene 能够几乎适用于所有的搜索应用程序。

索引和搜索

索引是现代搜索引擎的核心，建立索引的过程就是把源数据处理成非常方便查询的索引文件的过程。为什么索引这么重要呢，试想你现在要在大量的文档中搜索含有某个关键词的文档，那么如果不建立索引的话你就需要把这些文档顺序的读入内存，然后检查这个文章中是不是含有要查找的关键词，这样的话就会耗费非常多的时间。Lucene 采用的是一种称为反向索引的机制。反向索引就是说我们维护了一个词/短语表，对于这个表中的每个词/短语，都有一个链表描述了有哪些文档包含了这个词/短语。这样在用户输入查询条件的时候，就能非常快的得到搜索结果。对文档建立好索引后，就可以在这些索引上面进行搜索了。搜索引擎首先会对搜索的关键词进行解析，然后再在建立好的索引上面进行查找，最终返回和用户输入的关键词相关联的文档。

一个简单的搜索应用程序

假设我们的电脑的目录中含有很多文本文档，我们需要查找哪些文档含有某个关键词。为了实现这种功能，我们首先利用 Lucene 对这个目录中的文档建立索引，然后在建立好的索引中搜索我们所要查找的文档。通过这个例子读者会对如何利用 Lucene 构建自己的搜索应用程序有个比较清楚的认识。

建立索引
为了对文档进行索引，Lucene 提供了五个基础的类，他们分别是 Document, Field, IndexWriter, Analyzer, Directory。下面我们分别介绍一下这五个类的用途：

Document
Document 是用来描述文档的，这里的文档可以指一个 HTML 页面，一封电子邮件，或者是一个文本文件。一个 Document 对象由多个 Field 对象组成的。可以把一个 Document 对象想象成数据库中的一个记录，而每个 Field 对象就是记录的一个字段。

Field
Field 对象是用来描述一个文档的某个属性的，比如一封电子邮件的标题和内容可以用两个 Field 对象分别描述。

Analyzer
在一个文档被索引之前，首先需要对文档内容进行分词处理，这部分工作就是由 Analyzer 来做的。Analyzer 类是一个抽象类，它有多个实现。针对不同的语言和应用需要选择适合的 Analyzer。Analyzer 把分词后的内容交给 IndexWriter 来建立索引。

IndexWriter
IndexWriter 是 Lucene 用来创建索引的一个核心的类，他的作用是把一个个的 Document 对象加到索引中来。

Directory
这个类代表了 Lucene 的索引的存储的位置，这是一个抽象类，它目前有两个实现，第一个是 FSDirectory，它表示一个存储在文件系统中的索引的位置。第二个是 RAMDirectory，它表示一个存储在内存当中的索引的位置。
熟悉了建立索引所需要的这些类后，我们就开始对某个目录下面的文本文件建立索引了，清单1给出了对某个目录下的文本文件建立索引的源代码。

清单 1. 对文本文件建立索引
package TestLucene;
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 demonstrate the process of creating index with Lucene
* for text files
*/
public class TxtFileIndexer {
public static void main(String[] args) throws Exception{
//indexDir is the directory that hosts Lucene's index files
        File   indexDir = new File("D:\\luceneIndex");
        //dataDir is the directory that hosts the text files that to be indexed
        File   dataDir = new File("D:\\luceneData");
        Analyzer luceneAnalyzer = new StandardAnalyzer();
        File[] dataFiles = dataDir.listFiles();
        IndexWriter indexWriter = new IndexWriter(indexDir,luceneAnalyzer,true);
        long startTime = new Date().getTime();
        for(int i = 0; i < dataFiles.length; i++){
        if(dataFiles[i].isFile() && dataFiles[i].getName().endsWith(".txt")){
        System.out.println("Indexing file " + dataFiles[i].getCanonicalPath());
        Document document = new Document();
        Reader txtReader = new FileReader(dataFiles[i]);
        document.add(Field.Text("path",dataFiles[i].getCanonicalPath()));
        document.add(Field.Text("contents",txtReader));
        indexWriter.addDocument(document);
        }
        }
        indexWriter.optimize();
        indexWriter.close();
        long endTime = new Date().getTime();

        System.out.println("It takes " + (endTime - startTime)
                           + " milliseconds to create index for the files in directory "
                   + dataDir.getPath());
}
}
  在清单1中，我们注意到类 IndexWriter 的构造函数需要三个参数，第一个参数指定了所创建的索引要存放的位置，他可以是一个 File 对象，也可以是一个 FSDirectory 对象或者 RAMDirectory 对象。第二个参数指定了 Analyzer 类的一个实现，也就是指定这个索引是用哪个分词器对文挡内容进行分词。第三个参数是一个布尔型的变量，如果为 true 的话就代表创建一个新的索引，为 false 的话就代表在原来索引的基础上进行操作。接着程序遍历了目录下面的所有文本文档，并为每一个文本文档创建了一个 Document 对象。然后把文本文档的两个属性：路径和内容加入到了两个 Field 对象中，接着在把这两个 Field 对象加入到 Document 对象中，最后把这个文档用 IndexWriter 类的 add 方法加入到索引中去。这样我们便完成了索引的创建。接下来我们进入在建立好的索引上进行搜索的部分。

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

清单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() 来完成恢复工作。

清单3：恢复已删除文档

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

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

清单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提供了几个基础的类来完成这个过程，它们分别是呢IndexSearcher, Term, Query, TermQuery, Hits. 下面我们分别介绍这几个类的功能。

Query
这是一个抽象类，他有多个实现，比如TermQuery, BooleanQuery, PrefixQuery. 这个类的目的是把用户输入的查询字符串封装成Lucene能够识别的Query。

Term
Term是搜索的基本单位，一个Term对象有两个String类型的域组成。生成一个Term对象可以有如下一条语句来完成：Term term = new Term(“fieldName”,”queryWord”); 其中第一个参数代表了要在文档的哪一个Field上进行查找，第二个参数代表了要查询的关键词。

TermQuery
TermQuery是抽象类Query的一个子类，它同时也是Lucene支持的最为基本的一个查询类。生成一个TermQuery对象由如下语句完成： TermQuery termQuery = new TermQuery(new Term(“fieldName”,”queryWord”)); 它的构造函数只接受一个参数，那就是一个Term对象。

IndexSearcher
IndexSearcher是用来在建立好的索引上进行搜索的。它只能以只读的方式打开一个索引，所以可以有多个IndexSearcher的实例在一个索引上进行操作。

Hits
Hits是用来保存搜索的结果的。

清单2 ：在建立好的索引上进行搜索
package TestLucene;
import java.io.File;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.Hits;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.store.FSDirectory;
/**
 * This class is used to demonstrate the 
 * process of searching on an existing 
 * Lucene index
 *
 */
public class TxtFileSearcher {
	public static void main(String[] args) throws Exception{
	    String queryStr = "lucene";
	    //This is the directory that hosts the Lucene index
        File indexDir = new File("D:\\luceneIndex");
        FSDirectory directory = FSDirectory.getDirectory(indexDir,false);
        IndexSearcher searcher = new IndexSearcher(directory);
        if(!indexDir.exists()){
        	System.out.println("The Lucene index is not exist");
        	return;
        }
        Term term = new Term("contents",queryStr.toLowerCase());
        TermQuery luceneQuery = new TermQuery(term);
        Hits hits = searcher.search(luceneQuery);
        for(int i = 0; i < hits.length(); i++){
        	Document document = hits.doc(i);
        	System.out.println("File: " + document.get("path"));
        }
	}
}

在清单2中，类IndexSearcher的构造函数接受一个类型为Directory的对象，Directory是一个抽象类，它目前有两个子类：
FSDirctory和RAMDirectory. 我们的程序中传入了一个FSDirctory对象作为其参数，代表了一个存储在磁盘上的索引的位置。构造函数执行完成后，
代表了这个 IndexSearcher以只读的方式打开了一个索引。然后我们程序构造了一个Term对象，通过这个Term对象，我们指定了要在文档的内容中搜索
包含关键词”lucene”的文档。接着利用这个Term对象构造出TermQuery对象并把这个TermQuery对象传入到 IndexSearcher的search方法中进行查询
，返回的结果保存在Hits对象中。最后我们用了一个循环语句把搜索到的文档的路径都打印了出来。好了，我们的搜索应用程序已经开发完毕。

提高索引性能

利用 Lucene，在创建索引的工程中你可以充分利用机器的硬件资源来提高索引的效率。当你需要索引大量的文件时，你会注意到索引过程的瓶颈是在往

磁盘

上写索引文件的过程中。为了解决这个问题, Lucene 在内存中持有一块缓冲区。但我们如何控制 Lucene 的缓冲区呢？幸运的是，Lucene 的类

IndexWriter 提供了三个参数用来调整缓冲区的大小以及往磁盘上写索引文件的频率。

1．合并因子（mergeFactor）

这个参数决定了在 Lucene 的一个索引块中可以存放多少文档以及把磁盘上的索引块合并成一个大的索引块的频率。比如，如果合并因子的值是 10，

那么当内存中的文档数达到 10 的时候所有的文档都必须写到磁盘上的一个新的索引块中。并且，如果磁盘上的索引块的隔数达到 10 的话，这 10 个

索引块会被合并成一个新的索引块。这个参数的默认值是 10，如果需要索引的文档数非常多的话这个值将是非常不合适的。对批处理的索引来讲，为这个

参数赋一个比较大的值会得到比较好的索引效果。

2．最小合并文档数

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

尽量设的比较大一些将会显著的提高索引性能。

3．最大合并文档数

这个参数决定了一个索引块中的最大的文档数。它的默认值是 Integer.MAX_VALUE，将这个参数设置为比较大的值可以提高索引效率和检索速度，由于

该参数的默认值是整型的最大值，所以我们一般不需要改动这个参数。

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;

表1：测试结果

通过表 1，你可以清楚地看到三个参数对索引时间的影响。在实践中，你会经常的改变合并因子和最小合并文档数的值来提高索引性能。只要你有足够大

的内存，你可以为合并因子和最小合并文档数这两个参数赋尽量大的值以提高索引效率，另外我们一般无需更改最大合并文档数这个参数的值，因为系统

已经默认将它设置成了最大。

Lucene 索引机制

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

文本格式解析

lucene只能对纯文本格式进行索引，如果是其他格式的文档必须转化为文本格式。

html格式使用htmlparse包来解析；

pdf格式使用pdfbox包来解析；

word,excel,ppt使用poi包来解析；