private static TimeZone  defaultZone = null;

      public static synchronized void setDefault(TimeZone zone)
      {
          defaultZone = zone;
      }

          ... 
package.definition=Package#1 [,Package#2,...,Package#n]

...

... 
RuntimePermission("defineClassInPackage."+package)

...

      ... 
package.access=Package#1 [,Package#2,...,Package#n]

...

... 
RuntimePermission("defineClassInPackage."+package)

...

      public class YourClass implements Serializable {

            private byte [] internalArray;
....
private synchronized void writeObject(ObjectOutputStream stream) {
 ...

               stream.write(internalArray);
                ...
}
}

       public class HackerObjectOutputStream extends ObjectOutputStream{
            public void write (byte [] b) {
               Modify b
      }
}
 ...
             YourClass yc = new YourClass();
              ...

             HackerObjectOutputStream hoos = new HackerObjectOutputStream();

              hoos.writeObject(yc);

MySQL从3.23.15版本以后提供数据库复制功能。利用该功能可以实现两个数据库同步，主从模式，互相备份模式的功能

数据库同步复制功能的设置都在mysql的设置文件中体现。mysql的配置文件（一般是my.cnf），在unix环境下在/etc/mysql/my.cnf 或者在mysql用户的home目录下的my.cnf。

window环境中，如果c:根目录下有my.cnf文件则取该配置文件。当运行mysql的winmysqladmin.exe工具时候，该工具会把c:根目录下的my.cnf 命名为mycnf.bak。并在winnt目录下创建my.ini。mysql服务器启动时候会读该配置文件。所以可以把my.cnf中的内容拷贝到my.ini文件中，用my.ini文件作为mysql服务器的配置文件。

设置方法：

设置范例环境：

操作系统：window2000 professional

mysql：4.0.4-beta-max-nt-log

A ip:10.10.10.22

B ip:10.10.10.53

A:设置

1.增加一个用户最为同步的用户帐号：

																GRANT FILE ON *.* TO backup@'10.10.10.53' IDENTIFIED BY ‘1234’
														

2.增加一个数据库作为同步数据库：

																create database backup
														

B:设置

1.增加一个用户最为同步的用户帐号：

																GRANT FILE ON *.* TO backup@'10.10.10.22' IDENTIFIED BY ‘1234’
														

2.增加一个数据库作为同步数据库：

																create database backup
														

主从模式：A->B

A为master

修改A mysql的my.ini文件。在mysqld配置项中加入下面配置：

server-id=1log-bin#设置需要记录log 可以设置log-bin=c:mysqlbakmysqllog 设置日志文件的目录，#其中mysqllog是日志文件的名称，mysql将建立不同扩展名，文件名为mysqllog的几个日志文件。binlog-do-db=backup #指定需要日志的数据库

重起数据库服务。

用show master status 命令看日志情况。

B为slave

修改B mysql的my.ini文件。在mysqld配置项中加入下面配置：

																server-id=2master-host=10.10.10.22master-user=backup
														

#同步用户帐号

																master-password=1234master-port=3306master-connect-retry=60
														

预设重试间隔60秒replicate-do-db=backup 告诉slave只做backup数据库的更新

重起数据库

用show slave status看同步配置情况。

注意：由于设置了slave的配置信息，mysql在数据库目录下生成master.info，所以如有要修改相关slave的配置要先删除该文件。否则修改的配置不能生效。

双机互备模式。

如果在A加入slave设置，在B加入master设置，则可以做B->A的同步。

在A的配置文件中 mysqld 配置项加入以下设置：

																master-host=10.10.10.53master-user=backupmaster-password=1234replicate-do-db=
backupmaster-connect-retry=10
														

在B的配置文件中 mysqld 配置项加入以下设置：

																log-bin=c:mysqllogmysqllogbinlog-do-db=backup
														

注意：当有错误产生时*.err日志文件。同步的线程退出，当纠正错误后要让同步机制进行工作，运行slave start

重起AB机器，则可以实现双向的热备。

测试：

向B批量插入大数据量表AA（1872000）条，A数据库每秒钟可以更新2500条数据。

关注beanaction时,查到的资料,顺便做个备份

多数IT 组织都必须解决三个主要问题：1．帮助组织减少成本 2．增加并且保持客户 3．加快业务效率。完成这些问题一般都需要实现对多个业务系统的数据和业务逻辑的无缝访问，也就是说，要实施系统集成工程，以便联结业务流程、实现数据的访问与共享。

JpetStore 4.0是ibatis的最新示例程序，基于Struts MVC框架（注：非传统Struts开发模式），以ibatis作为持久化层。该示例程序设计优雅，层次清晰，可以学习以及作为一个高效率的编程模型参考。本文是在其基础上，采用Spring对其中间层（业务层）进行改造。使开发量进一步减少，同时又拥有了Spring的一些好处…

1. 前言
JpetStore 4.0是ibatis的最新示例程序。ibatis是开源的持久层产品，包含SQL Maps 2.0 和 Data Access Objects 2.0 框架。JpetStore示例程序很好的展示了如何利用ibatis来开发一个典型的J2EE web应用程序。JpetStore有如下特点：

• ibatis数据层
• POJO业务层
• POJO领域类
• Struts MVC
• JSP 表示层

以下是本文用到的关键技术介绍，本文假设您已经对Struts，SpringFramewok，ibatis有一定的了解，如果不是，请首先查阅附录中的参考资料。

• Struts 是目前Java Web MVC框架中不争的王者。经过长达五年的发展，Struts已经逐渐成长为一个稳定、成熟的框架，并且占有了MVC框架中最大的市场份额。但是Struts某些技术特性上已经落后于新兴的MVC框架。面对Spring MVC、Webwork2 这些设计更精密，扩展性更强的框架，Struts受到了前所未有的挑战。但站在产品开发的角度而言，Struts仍然是最稳妥的选择。本文的原型例子JpetStore 4.0就是基于Struts开发的，但是不拘泥于Struts的传统固定用法，例如只用了一个自定义Action类，并且在form bean类的定义上也是开创性的，令人耳目一新，稍后将具体剖析一下。
• Spring Framework 实际上是Expert One-on-One J2EE Design and Development 一书中所阐述的设计思想的具体实现。Spring Framework的功能非常多。包含AOP、ORM、DAO、Context、Web、MVC等几个部分组成。Web、MVC暂不用考虑，JpetStore 4.0用的是更成熟的Struts和JSP；DAO由于目前Hibernate、JDO、ibatis的流行，也不考虑，JpetStore 4.0用的就是ibatis。因此最需要用的是AOP、ORM、Context。Context中，最重要的是Beanfactory，它能将接口与实现分开，非常强大。目前AOP应用最成熟的还是在事务管理上。
• ibatis 是一个功能强大实用的SQL Map工具，不同于其他ORM工具（如hibernate），它是将SQL语句映射成Java对象，而对于ORM工具，它的SQL语句是根据映射定义生成的。ibatis 以SQL开发的工作量和数据库移植性上的让步，为系统设计提供了更大的自由空间。有ibatis代码生成的工具，可以根据DDL自动生成ibatis代码，能减少很多工作量。

2. JpetStore简述

2.1. 背景
最初是Sun公司的J2EE petstore，其最主要目的是用于学习J2EE，但是其缺点也很明显，就是过度设计了。接着Oracle用J2EE petstore来比较各应用服务器的性能。微软推出了基于.Net平台的 Pet shop，用于竞争J2EE petstore。而JpetStore则是经过改良的基于struts的轻便框架J2EE web应用程序，相比来说，JpetStore设计和架构更优良，各层定义清晰，使用了很多最佳实践和模式，避免了很多"反模式"，如使用存储过程，在java代码中嵌入SQL语句，把HTML存储在数据库中等等。最新版本是JpetStore 4.0。

2.2. JpetStore开发运行环境的建立
1、开发环境

• Java SDK 1.4.2
• Apache Tomcat 4.1.31
• Eclipse-SDK-3.0.1-win32
• HSQLDB 1.7.2

2、Eclipse插件

• EMF SDK 2.0.1：Eclipse建模框架，lomboz插件需要，可以使用runtime版本。
• lomboz 3.0：J2EE插件，用来在Eclipse中开发J2EE应用程序
• Spring IDE 1.0.3：Spring Bean配置管理插件
• xmlbuddy_2.0.10：编辑XML，用免费版功能即可
• tomcatPluginV3：tomcat管理插件
• Properties Editor：编辑java的属性文件,并可以预览以及自动存盘为Unicode格式。免去了手工或者ANT调用native2ascii的麻烦。

3、示例源程序

• ibatis示例程序JpetStore 4.0 http://www.ibatis.com/jpetstore/jpetstore.html
• 改造后的源程序（+spring）（源码链接）

2.3. 架构

图1 JpetStore架构图

图1 是JPetStore架构图，更详细的内容请参见JPetStore的白皮书。参照这个架构图，让我们稍微剖析一下源代码，得出JpetStore 4.0的具体实现图（见图2），思路一下子就豁然开朗了。前言中提到的非传统的struts开发模式，关键就在struts Action类和form bean类上。

struts Action类只有一个：BeanAction。没错，确实是一个！与传统的struts编程方式很不同。再仔细研究BeanAction类，发现它其实是一个通用类，利用反射原理，根据URL来决定调用formbean的哪个方法。BeanAction大大简化了struts的编程模式，降低了对struts的依赖（与struts以及WEB容器有关的几个类都放在com.ibatis.struts包下，其它的类都可以直接复用）。利用这种模式，我们会很容易的把它移植到新的框架如JSF，spring。

这样重心就转移到form bean上了，它已经不是普通意义上的form bean了。查看源代码，可以看到它不仅仅有数据和校验/重置方法，而且已经具有了行为，从这个意义上来说，它更像一个BO(Business Object)。这就是前文讲到的，BeanAction类利用反射原理，根据URL来决定调用form bean的哪个方法（行为）。form bean的这些方法的签名很简单，例如：

												
 public String myActionMethod() {
   //..work
   return "success";
 }
 
										

方法的返回值直接就是字符串，对应的是forward的名称，而不再是ActionForward对象，创建ActionForward对象的任务已经由BeanAction类代劳了。

另外，程序还提供了ActionContext工具类，该工具类封装了request 、response、form parameters、request attributes、session attributes和 application attributes中的数据存取操作，简单而线程安全，form bean类使用该工具类可以进一步从表现层框架解耦。

在这里需要特别指出的是，BeanAction类是对struts扩展的一个有益尝试，虽然提供了非常好的应用开发模式，但是它还非常新，一直在发展中。

图2 JpetStore 4.0具体实现

2.4. 代码剖析
下面就让我们开始进一步分析JpetStore4.0的源代码，为下面的改造铺路。

• BeanAction.java是唯一一个Struts action类，位于com.ibatis.struts包下。正如上文所言，它是一个通用的控制类，利用反射机制，把控制转移到form bean的某个方法来处理。详细处理过程参考其源代码，简单明晰。

• Form bean类位于com.ibatis.jpetstore.presentation包下，命名规则为***Bean。Form bean类全部继承于BaseBean类，而BaseBean类实际继承于ActionForm，因此，Form bean类就是Struts的 ActionForm，Form bean类的属性数据就由struts框架自动填充。而实际上，JpetStore4.0扩展了struts中ActionForm的应用： Form bean类还具有行为，更像一个BO,其行为（方法）由BeanAction根据配置（struts-config.xml）的URL来调用。虽然如此，我们还是把Form bean类定位于表现层。

  Struts-config.xml的配置里有3种映射方式，来告诉BeanAction把控制转到哪个form bean对象的哪个方法来处理。

  以这个请求连接为例http://localhost/jpetstore4/shop/viewOrder.do

  1. URL Pattern

  <action path="/shop/viewOrder" type="com.ibatis.struts.BeanAction" name="orderBean" scope="session" validate="false"> <forward name="success" path="/order/ViewOrder.jsp"/> </action>

  此种方式表示，控制将被转发到"orderBean"这个form bean对象 的"viewOrder"方法（行为）来处理。方法名取"path"参数的以"/"分隔的最后一部分。

  2. Method Parameter

  <action path="/shop/viewOrder" type="com.ibatis.struts.BeanAction" name="orderBean" parameter="viewOrder" scope="session" validate="false"> <forward name="success" path="/order/ViewOrder.jsp"/> </action>

  此种方式表示，控制将被转发到"orderBean"这个form bean对象的"viewOrder"方法（行为）来处理。配置中的"parameter"参数表示form bean类上的方法。"parameter"参数优先于"path"参数。

  3. No Method call

  <action path="/shop/viewOrder" type="com.ibatis.struts.BeanAction" name="orderBean" parameter="*" scope="session" validate="false"> <forward name="success" path="/order/ViewOrder.jsp"/> </action>

  此种方式表示，form bean上没有任何方法被调用。如果存在"name"属性，则struts把表单参数等数据填充到form bean对象后，把控制转发到"success"。否则，如果name为空，则直接转发控制到"success"。

  这就相当于struts内置的org.apache.struts.actions.ForwardAction的功能

  <action path="/shop/viewOrder" type="org.apache.struts.actions.ForwardAction" parameter="/order/ViewOrder.jsp " scope="session" validate="false"> </action>

• Service类位于com.ibatis.jpetstore.service包下，属于业务层。这些类封装了业务以及相应的事务控制。Service类由form bean类来调用。
• com.ibatis.jpetstore.persistence.iface包下的类是DAO接口，属于业务层，其屏蔽了底层的数据库操作，供具体的Service类来调用。DaoConfig类是工具类（DAO工厂类），Service类通过DaoConfig类来获得相应的DAO接口，而不用关心底层的具体数据库操作，实现了如图2中{耦合2}的解耦。
• com.ibatis.jpetstore.persistence.sqlmapdao包下的类是对应DAO接口的具体实现，在JpetStore4.0中采用了ibatis来实现ORM。这些实现类继承BaseSqlMapDao类，而BaseSqlMapDao类则继承ibatis DAO 框架中的SqlMapDaoTemplate类。ibatis的配置文件存放在com.ibatis.jpetstore.persistence.sqlmapdao.sql目录下。这些类和配置文件位于数据层
• Domain类位于com.ibatis.jpetstore.domain包下，是普通的javabean。在这里用作数据传输对象（DTO），贯穿视图层、业务层和数据层，用于在不同层之间传输数据。

剩下的部分就比较简单了，请看具体的源代码，非常清晰。

2.5. 需要改造的地方
JpetStore4.0的关键就在struts Action类和form bean类上，这也是其精华之一（虽然该实现方式是试验性，待扩充和验证），在此次改造中我们要保留下来，即控制层一点不变，表现层获取相应业务类的方式变了（要加载spring环境），其它保持不变。要特别关注的改动是业务层和持久层，幸运的是JpetStore4.0设计非常好，需要改动的地方非常少，而且由模式可循，如下：

1. 业务层和数据层用Spring BeanFactory机制管理。

2. 业务层的事务由spring 的aop通过声明来完成。

3. 表现层（form bean）获取业务类的方法改由自定义工厂类来实现（加载spring环境）。

3. JPetStore的改造

3.1. 改造后的架构

其中红色部分是要增加的部分，蓝色部分是要修改的部分。下面就让我们逐一剖析。

3.2. Spring Context的加载
为了在Struts中加载Spring Context，一般会在struts-config.xml的最后添加如下部分：

												
<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
<set-property property="contextConfigLocation"
value="/WEB-INF/applicationContext.xml" />
</plug-in>

										

Spring在设计时就充分考虑到了与Struts的协同工作，通过内置的Struts Plug-in在两者之间提供了良好的结合点。但是，因为在这里我们一点也不改动JPetStore的控制层(这是JpetStore4.0的精华之一)，所以本文不准备采用此方式来加载ApplicationContext。我们利用的是spring framework 的BeanFactory机制,采用自定义的工具类（bean工厂类）来加载spring的配置文件，从中可以看出Spring有多灵活，它提供了各种不同的方式来使用其不同的部分/层次，您只需要用你想用的，不需要的部分可以不用。

具体的来说，就是在com.ibatis.spring包下创建CustomBeanFactory类，spring的配置文件applicationContext.xml也放在这个目录下。以下就是该类的全部代码，很简单：

												
public final class CustomBeanFactory {
	static XmlBeanFactory factory = null;
	static {
		Resource is = new
InputStreamResource( CustomBeanFactory.class.getResourceAsStream("applicationContext.xml"));
		factory = new XmlBeanFactory(is);			
	}
	public static Object getBean(String beanName){
		return factory.getBean(beanName);
	}
}

										

实际上就是封装了Spring 的XMLBeanFactory而已，并且Spring的配置文件只需要加载一次，以后就可以直接用CustomBeanFactory.getBean("someBean")来获得需要的对象了(例如someBean)，而不需要知道具体的类。CustomBeanFactory类用于{耦合1}的解耦。

CustomBeanFactory类在本文中只用于表现层的form bean对象获得service类的对象，因为我们没有把form bean对象配置在applicationContext.xml中。但是，为什么不把表现层的form bean类也配置起来呢，这样就用不着这CustomBeanFactory个类了，Spring会帮助我们创建需要的一切？问题的答案就在于form bean类是struts的ActionForm类！如果大家熟悉struts，就会知道ActionForm类是struts自动创建的：在一次请求中，struts判断，如果ActionForm实例不存在，就创建一个ActionForm对象，把客户提交的表单数据保存到ActionForm对象中。因此formbean类的对象就不能由spring来创建，但是service类以及数据层的DAO类可以，所以只有他们在spring中配置。

所以，很自然的，我们就创建了CustomBeanFactory类，在表现层来衔接struts和spring。就这么简单，实现了另一种方式的{耦合一}的解耦。

3.3. 表现层
上 面分析到，struts和spring是在表现层衔接起来的，那么表现层就要做稍微的更改，即所需要的service类的对象创建上。以表现层的AccountBean类为例：

原来的源代码如下

												
														 private static final AccountService accountService = AccountService.getInstance();
  private static final CatalogService catalogService = CatalogService.getInstance();
  
												
										

改造后的源代码如下

												
  private static final AccountService accountService = (AccountService)CustomBeanFactory.getBean("AccountService");
  private static final CatalogService catalogService = (CatalogService)CustomBeanFactory.getBean("CatalogService");

										

其他的几个presentation类以同样方式改造。这样，表现层就完成了。关于表现层的其它部分如JSP等一概不动。也许您会说，没有看出什么特别之处的好处啊？你还是额外实现了一个工厂类。别着急，帷幕刚刚开启，spring是在表现层引入，但您发没发现：

• presentation类仅仅面向service类的接口编程，具体"AccountService"是哪个实现类，presentation类不知道，是在spring的配置文件里配置。（本例中，为了最大限度的保持原来的代码不作变化，没有抽象出接口）。Spring鼓励面向接口编程，因为是如此的方便和自然，当然您也可以不这么做。
• CustomBeanFactory这个工厂类为什么会如此简单，因为其直接使用了Spring的BeanFactory。Spring从其核心而言，是一个DI容器，其设计哲学是提供一种无侵入式的高扩展性的框架。为了实现这个目标，Spring 大量引入了Java 的Reflection机制，通过动态调用的方式避免硬编码方式的约束，并在此基础上建立了其核心组件BeanFactory，以此作为其依赖注入机制的实现基础。org.springframework.beans包中包括了这些核心组件的实现类，核心中的核心为BeanWrapper和BeanFactory类。

3.4. 持久层
在讨论业务层之前，我们先看一下持久层，如下图所示：

在上文中，我们把iface包下的DAO接口归为业务层，在这里不需要做修改。ibatis的sql配置文件也不需要改。要改的是DAO实现类，并在spring的配置文件中配置起来。

1、修改基类

所有的DAO实现类都继承于BaseSqlMapDao类。修改BaseSqlMapDao类如下：

												
public class BaseSqlMapDao extends SqlMapClientDaoSupport {
  protected static final int PAGE_SIZE = 4;
  protected SqlMapClientTemplate smcTemplate = this.getSqlMapClientTemplate();
  public BaseSqlMapDao() { 
	}
}

										

使BaseSqlMapDao类改为继承于Spring提供的SqlMapClientDaoSupport类，并定义了一个保护属性smcTemplate，其类型为SqlMapClientTemplate。关于SqlMapClientTemplate类的详细说明请参照附录中的"Spring中文参考手册"

2、修改DAO实现类

所有的DAO实现类还是继承于BaseSqlMapDao类，实现相应的DAO接口，但其相应的DAO操作委托SqlMapClientTemplate来执行，以AccountSqlMapDao类为例，部分代码如下：

												
    public List getUsernameList() {
    return smcTemplate.queryForList("getUsernameList", null);
  }
  public Account getAccount(String username, String password) {
    Account account = new Account();
    account.setUsername(username);
    account.setPassword(password);
    return (Account) smcTemplate.queryForObject("getAccountByUsernameAndPassword", account);
  }
  public void insertAccount(Account account) {
  	smcTemplate.update("insertAccount", account);
  	smcTemplate.update("insertProfile", account);
  	smcTemplate.update("insertSignon", account);
  }
  
										

就这么简单，所有函数的签名都是一样的，只需要查找替换就可以了！

3、除去工厂类以及相应的配置文件

除去DaoConfig.java这个DAO工厂类和相应的配置文件dao.xml，因为DAO的获取现在要用spring来管理。

4、DAO在Spring中的配置（applicationContext.xml）

												
    <bean id="dataSource" 
        class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName">
            <value>org.hsqldb.jdbcDriver</value>
        </property>
        <property name="url">
            <value>jdbc:hsqldb:hsql://localhost/xdb</value>
        </property>
        <property name="username">
            <value>sa</value>
        </property>
        <property name="password">
            <value></value>
        </property>
    </bean>    
    <!-- ibatis sqlMapClient config -->
    <bean id="sqlMapClient" 
        class="org.springframework.orm.ibatis.SqlMapClientFactoryBean">
        <property name="configLocation">
            <value> 
                classpath:com\ibatis\jpetstore\persistence\sqlmapdao\sql\sql-map-config.xml
            </value>
        </property>
        <property name="dataSource">
            <ref bean="dataSource"/>
        </property>    
    </bean>
    <!-- Transactions -->
    <bean id="TransactionManager" 
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource">
            <ref bean="dataSource"/>
        </property>
    </bean>
    <!-- persistence layer -->
    <bean id="AccountDao" 
        class="com.ibatis.jpetstore.persistence.sqlmapdao.AccountSqlMapDao">
        <property name="sqlMapClient">
            <ref local="sqlMapClient"/>
        </property>
    </bean>
    
										

具体的语法请参照附录中的"Spring中文参考手册"。在这里只简单解释一下：

1. 我们首先创建一个数据源dataSource，在这里配置的是hsqldb数据库。如果是ORACLE数据库，driverClassName的值是"oracle.jdbc.driver.OracleDriver"，URL的值类似于"jdbc:oracle:thin:@wugfMobile:1521:cdcf"。数据源现在由spring来管理，那么现在我们就可以去掉properties目录下database.properties这个配置文件了；还有不要忘记修改sql-map-config.xml，去掉<properties resource="properties/database.properties"/>对它的引用。

2. sqlMapClient节点。这个是针对ibatis SqlMap的SqlMapClientFactoryBean配置。实际上配置了一个sqlMapClient的创建工厂类。configLocation属性配置了ibatis映射文件的名称。dataSource属性指向了使用的数据源，这样所有使用sqlMapClient的DAO都默认使用了该数据源，除非在DAO的配置中另外显式指定。

3. TransactionManager节点。定义了事务，使用的是DataSourceTransactionManager。

4. 下面就可以定义DAO节点了，如AccountDao，它的实现类是com.ibatis.jpetstore.persistence.sqlmapdao.AccountSqlMapDao，使用的SQL配置从sqlMapClient中读取，数据库连接没有特别列出，那么就是默认使用sqlMapClient配置的数据源datasource。

这样，我们就把持久层改造完了，其他的DAO配置类似于AccountDao。怎么样？简单吧。这次有接口了：） AccountDao接口－>AccountSqlMapDao实现。

3.5. 业务层
业务层的位置以及相关类，如下图所示：

在这个例子中只有3个业务类，我们以OrderService类为例来改造，这个类是最复杂的，其中涉及了事务。

1、在ApplicationContext配置文件中增加bean的配置：

												
    <bean id="OrderService" 
        class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
        <property name="transactionManager">
            <ref local="TransactionManager"></ref>
        </property>
        <property name="target">
            <bean class="com.ibatis.jpetstore.service.OrderService">
                <property name="itemDao">
                    <ref bean="ItemDao"/>
                </property>
                <property name="orderDao">
                    <ref bean="OrderDao"/>
                </property>
                <property name="sequenceDao">
                    <ref bean="SequenceDao"/>
                </property>
            </bean>
        </property>
        <property name="transactionAttributes">
            <props>
                <prop key="insert*">PROPAGATION_REQUIRED</prop>
            </props>
        </property>
    </bean>
    
										

定义了一个OrderService，还是很容易懂的。为了简单起见，使用了嵌套bean，其实现类是com.ibatis.jpetstore.service.OrderService，分别引用了ItemDao，OrderDao，SequenceDao。该bean的insert*实现了事务管理(AOP方式)。TransactionProxyFactoryBean自动创建一个事务advisor， 该advisor包括一个基于事务属性的pointcut,因此只有事务性的方法被拦截。

2、业务类的修改

以OrderService为例：

												
public class OrderService {

   /* Private Fields */
  private ItemDao itemDao;
  private OrderDao orderDao;
  private SequenceDao sequenceDao;

  /* Constructors */

  public OrderService() {
  }

/**
 * @param itemDao 要设置的 itemDao。
 */
public final void setItemDao(ItemDao itemDao) {
	this.itemDao = itemDao;
}
/**
 * @param orderDao 要设置的 orderDao。
 */
public final void setOrderDao(OrderDao orderDao) {
	this.orderDao = orderDao;
}
/**
 * @param sequenceDao 要设置的 sequenceDao。
 */
public final void setSequenceDao(SequenceDao sequenceDao) {
	this.sequenceDao = sequenceDao;
}
//剩下的部分
…….
}

										

红色部分为修改部分。Spring采用的是Type2的设置依赖注入，所以我们只需要定义属性和相应的设值函数就可以了，ItemDao，OrderDao，SequenceDao的值由spring在运行期间注入。构造函数就可以为空了，另外也不需要自己编写代码处理事务了（事务在配置中声明），daoManager.startTransaction();等与事务相关的语句也可以去掉了。和原来的代码比较一下，是不是处理精简了很多！可以更关注业务的实现。

4. 结束语
ibatis是一个功能强大实用的SQL Map工具，可以直接控制SQL,为系统设计提供了更大的自由空间。其提供的最新示例程序JpetStore 4.0,设计优雅，应用了迄今为止很多最佳实践和设计模式，非常适于学习以及在此基础上创建轻量级的J2EE WEB应用程序。JpetStore 4.0是基于struts的，本文在此基础上，最大程度保持了原有设计的精华以及最小的代码改动量，在业务层和持久化层引入了Spring。在您阅读了本文以及改造后的源代码后，会深切的感受到Spring带来的种种好处：自然的面向接口的编程，业务对象的依赖注入，一致的数据存取框架和声明式的事务处理，统一的配置文件…更重要的是Spring既是全面的又是模块化的，Spring有分层的体系结构，这意味着您能选择仅仅使用它任何一个独立的部分，就像本文，而它的架构又是内部一致。

因了需要用到这些信息,所以总结一下,方便以后参阅
通过request.getHeader("User-Agent")大致可以取得用户浏览器的信息
如果里面包含：
"msie"-->MicroSoft 
"opera" -->Opera Software
"mozilla"-->Netscape Communications

如果取浏览器版本信息
String str = request.getHeader("User-Agent");
MS :  str.substring(str.indexOf("msie") + 5);
Other :
tmpString = (str.substring(tmpPos = (str.indexOf("/")) + 1, tmpPos + str.indexOf(" "))).trim();  //没有亲自试

操作系统部分,不啰嗦了
private void setOs()
{
if (this.userAgent.indexOf("win") > -1){
  if (this.userAgent.indexOf("windows 95") > -1 || this.userAgent.indexOf("win95") > -1){
     this.os = "Windows 95";
  }
  if (this.userAgent.indexOf("windows 98") > -1 || this.userAgent.indexOf("win98") > -1){
     this.os = "Windows 98";
  }
  if (this.userAgent.indexOf("windows nt") > -1 || this.userAgent.indexOf("winnt") > -1){
      this.os = "Windows NT";
  }
  if (this.userAgent.indexOf("win16") > -1 || this.userAgent.indexOf("windows 3.") > -1){
      this.os = "Windows 3.x";
  }
 }
}

获取语言request.getHeader("Accept-Language");

详细信息可以再分解....

Lucene 是基于 Java 的全文信息检索包，它目前是 Apache Jakarta 家族下面的一个开源项目。在这篇文章中，我们首先来看如何利用 Lucene 实现高级搜索功能，然后学习如何利用 Lucene 来创建一个健壮的 Web 搜索应用程序。

在本篇文章中，你会学习到如何利用 Lucene 实现高级搜索功能以及如何利用 Lucene 来创建 Web 搜索应用程序。通过这些学习，你就可以利用 Lucene 来创建自己的搜索应用程序。

架构概览

通常一个 Web 搜索引擎的架构分为前端和后端两部分，就像图一中所示。在前端流程中，用户在搜索引擎提供的界面中输入要搜索的关键词，这里提到的用户界面一般是一个带有输入框的 Web 页面，然后应用程序将搜索的关键词解析成搜索引擎可以理解的形式，并在索引文件上进行搜索操作。在排序后，搜索引擎返回搜索结果给用户。在后端流程中，网络爬虫或者机器人从因特网上获取 Web 页面，然后索引子系统解析这些 Web 页面并存入索引文件中。如果你想利用 Lucene 来创建一个 Web 搜索应用程序，那么它的架构也和上面所描述的类似，就如图一中所示。

利用 Lucene 实现高级搜索

Lucene 支持多种形式的高级搜索，我们在这一部分中会进行探讨，然后我会使用 Lucene 的 API 来演示如何实现这些高级搜索功能。

布尔操作符

大多数的搜索引擎都会提供布尔操作符让用户可以组合查询，典型的布尔操作符有 AND, OR, NOT。Lucene 支持 5 种布尔操作符，分别是 AND, OR, NOT, 加(+), 减(-)。接下来我会讲述每个操作符的用法。

• OR: 如果你要搜索含有字符 A 或者 B 的文档，那么就需要使用 OR 操作符。需要记住的是，如果你只是简单的用空格将两个关键词分割开，其实在搜索的时候搜索引擎会自动在两个关键词之间加上 OR 操作符。例如，“Java OR Lucene” 和 “Java Lucene” 都是搜索含有 Java 或者含有 Lucene 的文档。
• AND: 如果你需要搜索包含一个以上关键词的文档，那么就需要使用 AND 操作符。例如，“Java AND Lucene” 返回所有既包含 Java 又包含 Lucene 的文档。
• NOT: Not 操作符使得包含紧跟在 NOT 后面的关键词的文档不会被返回。例如，如果你想搜索所有含有 Java 但不含有 Lucene 的文档，你可以使用查询语句 “Java NOT Lucene”。但是你不能只对一个搜索词使用这个操作符，比如，查询语句 “NOT Java” 不会返回任何结果。
• 加号（+）: 这个操作符的作用和 AND 差不多，但它只对紧跟着它的一个搜索词起作用。例如，如果你想搜索一定包含 Java，但不一定包含 Lucene 的文档，就可以使用查询语句“+Java Lucene”。
• 减号（-）: 这个操作符的功能和 NOT 一样，查询语句 “Java -Lucene” 返回所有包含 Java 但不包含 Lucene 的文档。

接下来我们看一下如何利用 Lucene 提供的 API 来实现布尔查询。清单1 显示了如果利用布尔操作符进行查询的过程。

  //Test boolean operator
public void testOperator(String indexDirectory) throws Exception{
   Directory dir = FSDirectory.getDirectory(indexDirectory,false);
   IndexSearcher indexSearcher = new IndexSearcher(dir);
   String[] searchWords = {"Java AND Lucene", "Java NOT Lucene", "Java OR Lucene", 
                    "+Java +Lucene", "+Java -Lucene"};
   Analyzer language = new StandardAnalyzer();
   Query query;
   for(int i = 0; i < searchWords.length; i++){
      query = QueryParser.parse(searchWords[i], "title", language);
      Hits results = indexSearcher.search(query);
      System.out.println(results.length() + "search results for query " + searchWords[i]);
   }
}

域搜索(Field Search)

Lucene 支持域搜索，你可以指定一次查询是在哪些域(Field)上进行。例如，如果索引的文档包含两个域，Title 和 Content，你就可以使用查询 “Title: Lucene AND Content: Java” 来返回所有在 Title 域上包含 Lucene 并且在 Content 域上包含 Java 的文档。清单 2 显示了如何利用 Lucene 的 API 来实现域搜索。

//Test field search
public void testFieldSearch(String indexDirectory) throws Exception{
    Directory dir = FSDirectory.getDirectory(indexDirectory,false);
    IndexSearcher indexSearcher = new IndexSearcher(dir);
    String searchWords = "title:Lucene AND content:Java";
    Analyzer language = new StandardAnalyzer();
    Query query = QueryParser.parse(searchWords, "title", language);
    Hits results = indexSearcher.search(query);
    System.out.println(results.length() + "search results for query " + searchWords);
}

通配符搜索(Wildcard Search)

Lucene 支持两种通配符：问号（？）和星号（*）。你可以使用问号（？）来进行单字符的通配符查询，或者利用星号（*）进行多字符的通配符查询。例如，如果你想搜索 tiny 或者 tony，你就可以使用查询语句 “t?ny”；如果你想查询 Teach, Teacher 和 Teaching，你就可以使用查询语句 “Teach*”。清单3 显示了通配符查询的过程。

//Test wildcard search
public void testWildcardSearch(String indexDirectory)throws Exception{
   Directory dir = FSDirectory.getDirectory(indexDirectory,false);
   IndexSearcher indexSearcher = new IndexSearcher(dir);
   String[] searchWords = {"tex*", "tex?", "?ex*"};
   Query query;
   for(int i = 0; i < searchWords.length; i++){
      query = new WildcardQuery(new Term("title",searchWords[i]));
      Hits results = indexSearcher.search(query);
      System.out.println(results.length() + "search results for query " + searchWords[i]);
   }
}

模糊查询

Lucene 提供的模糊查询基于编辑距离算法(Edit distance algorithm)。你可以在搜索词的尾部加上字符 ~ 来进行模糊查询。例如，查询语句 “think~” 返回所有包含和 think 类似的关键词的文档。清单 4 显示了如果利用 Lucene 的 API 进行模糊查询的代码。

//Test fuzzy search
public void testFuzzySearch(String indexDirectory)throws Exception{
   Directory dir = FSDirectory.getDirectory(indexDirectory,false);
   IndexSearcher indexSearcher = new IndexSearcher(dir);
   String[] searchWords = {"text", "funny"};
   Query query;
   for(int i = 0; i < searchWords.length; i++){
      query = new FuzzyQuery(new Term("title",searchWords[i]));
      Hits results = indexSearcher.search(query);
      System.out.println(results.length() + "search results for query " + searchWords[i]);
   }
}

范围搜索(Range Search)

范围搜索匹配某个域上的值在一定范围的文档。例如，查询 “age:[18 TO 35]” 返回所有 age 域上的值在 18 到 35 之间的文档。清单5显示了利用 Lucene 的 API 进行返回搜索的过程。

//Test range search
public void testRangeSearch(String indexDirectory)throws Exception{
    Directory dir = FSDirectory.getDirectory(indexDirectory,false);
    IndexSearcher indexSearcher = new IndexSearcher(dir);
    Term begin = new Term("birthDay","20000101");
    Term end   = new Term("birthDay","20060606");
    Query query = new RangeQuery(begin,end,true);
    Hits results = indexSearcher.search(query);
    System.out.println(results.length() + "search results is returned");
}

回页首

在 Web 应用程序中集成 Lucene

接下来我们开发一个 Web 应用程序利用 Lucene 来检索存放在文件服务器上的 HTML 文档。在开始之前，需要准备如下环境：

1. Eclipse 集成开发环境
2. Tomcat 5.0
3. Lucene Library
4. JDK 1.5

这个例子使用 Eclipse 进行 Web 应用程序的开发，最终这个 Web 应用程序跑在 Tomcat 5.0 上面。在准备好开发所必需的环境之后，我们接下来进行 Web 应用程序的开发。

1、创建一个动态 Web 项目

1. 在 Eclipse 里面，选择 File > New > Project，然后再弹出的窗口中选择动态 Web 项目，如图二所示。

2. 在创建好动态 Web 项目之后，你会看到创建好的项目的结构，如图三所示，项目的名称为 sample.dw.paper.lucene。

2. 设计 Web 项目的架构

在我们的设计中，把该系统分成如下四个子系统：

1. 用户接口: 这个子系统提供用户界面使用户可以向 Web 应用程序服务器提交搜索请求，然后搜索结果通过用户接口来显示出来。我们用一个名为 search.jsp 的页面来实现该子系统。
2. 请求管理器: 这个子系统管理从客户端发送过来的搜索请求并把搜索请求分发到搜索子系统中。最后搜索结果从搜索子系统返回并最终发送到用户接口子系统。我们使用一个 Servlet 来实现这个子系统。
3. 搜索子系统: 这个子系统负责在索引文件上进行搜索并把搜索结构传递给请求管理器。我们使用 Lucene 提供的 API 来实现该子系统。
4. 索引子系统: 这个子系统用来为 HTML 页面来创建索引。我们使用 Lucene 的 API 以及 Lucene 提供的一个 HTML 解析器来创建该子系统。

图4 显示了我们设计的详细信息，我们将用户接口子系统放到 webContent 目录下面。你会看到一个名为 search.jsp 的页面在这个文件夹里面。请求管理子系统在包 sample.dw.paper.lucene.servlet 下面，类 SearchController 负责功能的实现。搜索子系统放在包 sample.dw.paper.lucene.search 当中，它包含了两个类，SearchManager 和 SearchResultBean，第一个类用来实现搜索功能，第二个类用来描述搜索结果的结构。索引子系统放在包 sample.dw.paper.lucene.index 当中。类 IndexManager 负责为 HTML 文件创建索引。该子系统利用包 sample.dw.paper.lucene.util 里面的类 HTMLDocParser 提供的方法 getTitle 和 getContent 来对 HTML 页面进行解析。

3. 子系统的实现

在分析了系统的架构设计之后，我们接下来看系统实现的详细信息。

1. 用户接口: 这个子系统有一个名为 search.jsp 的 JSP 文件来实现，这个 JSP 页面包含两个部分。第一部分提供了一个用户接口去向 Web 应用程序服务器提交搜索请求，如图5所示。注意到这里的搜索请求发送到了一个名为 SearchController 的 Servlet 上面。Servlet 的名字和具体实现的类的对应关系在 web.xml 里面指定。

这个JSP的第二部分负责显示搜索结果给用户，如图6所示：

2. 请求管理器: 一个名为 SearchController 的 servlet 用来实现该子系统。清单６给出了这个类的源代码。

package sample.dw.paper.lucene.servlet;

import java.io.IOException;
import java.util.List;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import sample.dw.paper.lucene.search.SearchManager;

/**
 * This servlet is used to deal with the search request
 * and return the search results to the client
 */
public class SearchController extends HttpServlet{

    private static final long serialVersionUID = 1L;

    public void doPost(HttpServletRequest request, HttpServletResponse response)
                      throws IOException, ServletException{
        String searchWord = request.getParameter("searchWord");
        SearchManager searchManager = new SearchManager(searchWord);
        List searchResult = null;
        searchResult = searchManager.search();
        RequestDispatcher dispatcher = request.getRequestDispatcher("search.jsp");
        request.setAttribute("searchResult",searchResult);
        dispatcher.forward(request, response);
    }

    public void doGet(HttpServletRequest request, HttpServletResponse response)
                     throws IOException, ServletException{
        doPost(request, response);
    }
}

在清单6中，doPost 方法从客户端获取搜索词并创建类 SearchManager 的一个实例，其中类 SearchManager 在搜索子系统中进行了定义。然后，SearchManager 的方法 search 会被调用。最后搜索结果被返回到客户端。

3. 搜索子系统: 在这个子系统中，我们定义了两个类：SearchManager 和 SearchResultBean。第一个类用来实现搜索功能，第二个类是个JavaBean，用来描述搜索结果的结构。清单7给出了类 SearchManager 的源代码。

package sample.dw.paper.lucene.search;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.queryParser.ParseException;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.Hits;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;

import sample.dw.paper.lucene.index.IndexManager;

/**
 * This class is used to search the 
 * Lucene index and return search results
 */
public class SearchManager {
	
    private String searchWord;
    
    private IndexManager indexManager;
    
    private Analyzer analyzer;
    
    public SearchManager(String searchWord){
        this.searchWord   =  searchWord;
        this.indexManager =  new IndexManager();
        this.analyzer     =  new StandardAnalyzer();
    }
    
    /**
     * do search
     */
    public List search(){
        List searchResult = new ArrayList();
        if(false == indexManager.ifIndexExist()){
        try {
            if(false == indexManager.createIndex()){
                return searchResult;
            }
        } catch (IOException e) {
          e.printStackTrace();
          return searchResult;
        }
        }
    	
        IndexSearcher indexSearcher = null;

        try{
            indexSearcher = new IndexSearcher(indexManager.getIndexDir());
        }catch(IOException ioe){
            ioe.printStackTrace();
        }

        QueryParser queryParser = new QueryParser("content",analyzer);
        Query query = null;
        try {
            query = queryParser.parse(searchWord);
        } catch (ParseException e) {
          e.printStackTrace();
        }
        if(null != query >> null != indexSearcher){			
            try {
                Hits hits = indexSearcher.search(query);
                for(int i = 0; i < hits.length(); i ++){
                    SearchResultBean resultBean = new SearchResultBean();
                    resultBean.setHtmlPath(hits.doc(i).get("path"));
                    resultBean.setHtmlTitle(hits.doc(i).get("title"));
                    searchResult.add(resultBean);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return searchResult;
    }
}
 

在清单7中，注意到在这个类里面有三个私有属性。第一个是 searchWord，代表了来自客户端的搜索词。第二个是 indexManager，代表了在索引子系统中定义的类 IndexManager 的一个实例。第三个是 analyzer，代表了用来解析搜索词的解析器。现在我们把注意力放在方法 search 上面。这个方法首先检查索引文件是否已经存在，如果已经存在，那么就在已经存在的索引上进行检索，如果不存在，那么首先调用类 IndexManager 提供的方法来创建索引，然后在新创建的索引上进行检索。搜索结果返回后，这个方法从搜索结果中提取出需要的属性并为每个搜索结果生成类 SearchResultBean 的一个实例。最后这些 SearchResultBean 的实例被放到一个列表里面并返回给请求管理器。

在类 SearchResultBean 中，含有两个属性，分别是 htmlPath 和 htmlTitle，以及这个两个属性的 get 和 set 方法。这也意味着我们的搜索结果包含两个属性：htmlPath 和 htmlTitle，其中 htmlPath 代表了 HTML 文件的路径，htmlTitle 代表了 HTML 文件的标题。

4. 索引子系统: 类 IndexManager 用来实现这个子系统。清单8 给出了这个类的源代码。

package sample.dw.paper.lucene.index;

import java.io.File;
import java.io.IOException;
import java.io.Reader;

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;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;

import sample.dw.paper.lucene.util.HTMLDocParser;

/**
 * This class is used to create an index for HTML files
 *
 */
public class IndexManager {

    //the directory that stores HTML files 
    private final String dataDir  = "c:\\dataDir";

    //the directory that is used to store a Lucene index
    private final String indexDir = "c:\\indexDir";

    /**
     * create index
     */
    public boolean createIndex() throws IOException{
        if(true == ifIndexExist()){
            return true;	
        }
        File dir = new File(dataDir);
        if(!dir.exists()){
            return false;
        }
        File[] htmls = dir.listFiles();
        Directory fsDirectory = FSDirectory.getDirectory(indexDir, true);
        Analyzer  analyzer    = new StandardAnalyzer();
        IndexWriter indexWriter = new IndexWriter(fsDirectory, analyzer, true);
        for(int i = 0; i < htmls.length; i++){
            String htmlPath = htmls[i].getAbsolutePath();

            if(htmlPath.endsWith(".html") || htmlPath.endsWith(".htm")){
        		addDocument(htmlPath, indexWriter);
        	}
        }
        indexWriter.optimize();
        indexWriter.close();
        return true;

    }

    /**
     * Add one document to the Lucene index
     */
    public void addDocument(String htmlPath, IndexWriter indexWriter){
        HTMLDocParser htmlParser = new HTMLDocParser(htmlPath);
        String path    = htmlParser.getPath();
        String title   = htmlParser.getTitle();
        Reader content = htmlParser.getContent();

        Document document = new Document();
        document.add(new Field("path",path,Field.Store.YES,Field.Index.NO));
        document.add(new Field("title",title,Field.Store.YES,Field.Index.TOKENIZED));
        document.add(new Field("content",content));
        try {
              indexWriter.addDocument(document);
    } catch (IOException e) {
              e.printStackTrace();
          }
    }

    /**
     * judge if the index exists already
     */
    public boolean ifIndexExist(){
        File directory = new File(indexDir);
        if(0 < directory.listFiles().length){
            return true;
        }else{
            return false;
        }
    }

    public String getDataDir(){
        return this.dataDir;
    }

    public String getIndexDir(){
        return this.indexDir;
    }

}

这个类包含两个私有属性，分别是 dataDir 和 indexDir。dataDir 代表存放等待进行索引的 HTML 页面的路径，indexDir 代表了存放 Lucene 索引文件的路径。类 IndexManager 提供了三个方法，分别是 createIndex, addDocument 和 ifIndexExist。如果索引不存在的话，你可以使用方法 createIndex 去创建一个新的索引，用方法 addDocument 去向一个索引上添加文档。在我们的场景中，一个文档就是一个 HTML 页面。方法 addDocument 会调用由类 HTMLDocParser 提供的方法对 HTML 文档进行解析。你可以使用最后一个方法 ifIndexExist 来判断 Lucene 的索引是否已经存在。

现在我们来看一下放在包 sample.dw.paper.lucene.util 里面的类 HTMLDocParser。这个类用来从 HTML 文件中提取出文本信息。这个类包含三个方法，分别是 getContent，getTitle 和 getPath。第一个方法返回去除了 HTML 标记的文本内容，第二个方法返回 HTML 文件的标题，最后一个方法返回 HTML 文件的路径。清单9 给出了这个类的源代码。

package sample.dw.paper.lucene.util;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.UnsupportedEncodingException;

import org.apache.lucene.demo.html.HTMLParser;

public class HTMLDocParser {
    private String htmlPath;

    private HTMLParser htmlParser;

    public HTMLDocParser(String htmlPath){
        this.htmlPath = htmlPath;
        initHtmlParser();
    }

    private void initHtmlParser(){
        InputStream inputStream = null;
        try {
            inputStream = new FileInputStream(htmlPath);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        if(null != inputStream){
	        try {
                htmlParser = new HTMLParser(new InputStreamReader(inputStream, "utf-8"));
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        }
    }

    public String getTitle(){
        if(null != htmlParser){
            try {
                return htmlParser.getTitle();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    return "";
    }

    public Reader getContent(){
    if(null != htmlParser){
            try {
                  return htmlParser.getReader();
              } catch (IOException e) {
                  e.printStackTrace();
              }
        }
        return null;
    }

    public String getPath(){
        return this.htmlPath;		
    }
}

5．在 Tomcat 5.0 上运行应用程序

现在我们可以在 Tomcat 5.0 上运行开发好的应用程序。

1. 右键单击 search.jsp，然后选择 Run as > Run on Server，如图7所示。

2. 在弹出的窗口中，选择 Tomcat v5.0 Server 作为目标 Web 应用程序服务器，然后点击 Next，如图8 所示：

3. 现在需要指定用来运行 Web 应用程序的 Apache Tomcat 5.0 以及 JRE 的路径。这里你所选择的 JRE 的版本必须和你用来编译 Java 文件的 JRE 的版本一致。配置好之后，点击 Finish。如 图9 所示。

4. 配置好之后，Tomcat 会自动运行，并且会对 search.jsp 进行编译并显示给用户。如 图10 所示。

5. 在输入框中输入关键词 “information” 然后单击 Search 按钮。然后这个页面上会显示出搜索结果来，如 图11 所示。

6. 单击搜索结果的第一个链接，页面上就会显示出所链接到的页面的内容。如 图12 所示.

现在我们已经成功的完成了示例项目的开发，并成功的用Lucene实现了搜索和索引功能。你可以下载这个项目的源代码（下载）。

回页首

总结

Lucene 提供了灵活的接口使我们更加方便的设计我们的 Web 搜索应用程序。如果你想在你的应用程序中加入搜索功能，那么 Lucene 是一个很好的选择。在设计你的下一个带有搜索功能的应用程序的时候可以考虑使用 Lucene 来提供搜索功能。

[原创文章，转载请保留或注明出处：http://www.regexlab.com/zh/encoding.htm]

级别：中级

摘要：本文介绍了字符与编码的发展过程，相关概念的正确理解。举例说明了一些实际应用中，编码的实现方法。然后，本文讲述了通常对字符与编码的几种误解，由于这些误解而导致乱码产生的原因，以及消除乱码的办法。本文的内容涵盖了“中文问题”，“乱码问题”。

掌握编码问题的关键是正确地理解相关概念，编码所涉及的技术其实是很简单的。因此，阅读本文时需要慢读多想，多思考。

引言

“字符与编码”是一个被经常讨论的话题。即使这样，时常出现的乱码仍然困扰着大家。虽然我们有很多的办法可以用来消除乱码，但我们并不一定理解这些办法的内在原理。而有的乱码产生的原因，实际上由于底层代码本身有问题所导致的。因此，不仅是初学者会对字符编码感到模糊，有的底层开发人员同样对字符编码缺乏准确的理解。

1. 编码问题的由来，相关概念的理解

1.1 字符与编码的发展

从计算机对多国语言的支持角度看，大致可以分为三个阶段：

字符串在内存中的存放方法：

在 ASCII 阶段，单字节字符串使用一个字节存放一个字符（SBCS）。比如，"Bob123" 在内存中为：

42	6F	62	31	32	33	00
B	o	b	1	2	3	\0

在使用 ANSI 编码支持多种语言阶段，每个字符使用一个字节或多个字节来表示（MBCS），因此，这种方式存放的字符也被称作多字节字符。比如，"中文123" 在中文 Windows 95 内存中为7个字节，每个汉字占2个字节，每个英文和数字字符占1个字节：

D6	D0	CE	C4	31	32	33	00
中		文		1	2	3	\0

在 UNICODE 被采用之后，计算机存放字符串时，改为存放每个字符在 UNICODE 字符集中的序号。目前计算机一般使用 2 个字节（16 位）来存放一个序号（DBCS），因此，这种方式存放的字符也被称作宽字节字符。比如，字符串 "中文123" 在 Windows 2000 下，内存中实际存放的是 5 个序号：

2D	4E	87	65	31	00	32	00	33	00	00	00	← 在 x86 CPU 中，低字节在前
中		文		1		2		3		\0

一共占 10 个字节。

1.2 字符，字节，字符串

理解编码的关键，是要把字符的概念和字节的概念理解准确。这两个概念容易混淆，我们在此做一下区分：

由于不同 ANSI 编码所规定的标准是不相同的，因此，对于一个给定的多字节字符串，我们必须知道它采用的是哪一种编码规则，才能够知道它包含了哪些“字符”。而对于 UNICODE 字符串来说，不管在什么环境下，它所代表的“字符”内容总是不变的。

回页首

1.3 字符集与编码

各个国家和地区所制定的不同 ANSI 编码标准中，都只规定了各自语言所需的“字符”。比如：汉字标准（GB2312）中没有规定韩国语字符怎样存储。这些 ANSI 编码标准所规定的内容包含两层含义：

1. 使用哪些字符。也就是说哪些汉字，字母和符号会被收入标准中。所包含“字符”的集合就叫做“字符集”。
2. 规定每个“字符”分别用一个字节还是多个字节存储，用哪些字节来存储，这个规定就叫做“编码”。

各个国家和地区在制定编码标准的时候，“字符的集合”和“编码”一般都是同时制定的。因此，平常我们所说的“字符集”，比如：GB2312, GBK, JIS 等，除了有“字符的集合”这层含义外，同时也包含了“编码”的含义。

“UNICODE 字符集”包含了各种语言中使用到的所有“字符”。用来给 UNICODE 字符集编码的标准有很多种，比如：UTF-8, UTF-7, UTF-16, UnicodeLittle, UnicodeBig 等。

回页首

1.4 常用的编码简介

简单介绍一下常用的编码规则，为后边的章节做一个准备。在这里，我们根据编码规则的特点，把所有的编码分成三类：

我们实际上没有必要去深究每一种编码具体把某一个字符编码成了哪几个字节，我们只需要知道“编码”的概念就是把“字符”转化成“字节”就可以了。对于“UNICODE 编码”，由于它们是可以通过计算得到的，因此，在特殊的场合，我们可以去了解某一种“UNICODE 编码”是怎样的规则。

回页首

2. 字符与编码在程序中的实现

2.1 程序中的字符与字节

在 C++ 和 Java 中，用来代表“字符”和“字节”的数据类型，以及进行编码的方法：

以上需要注意几点：

1. Java 中的 char 代表一个“UNICODE 字符（宽字节字符）”，而 C++ 中的 char 代表一个字节。
2. MultiByteToWideChar() 和 WideCharToMultiByte() 是 Windows API 函数。

回页首

2.2 C++ 中相关实现方法

声明一段字符串常量：

UNICODE 字符串的 I/O 操作，字符与字节的转换操作：

在 Visual C++ 中，UNICODE 字符串常量有更简单的表示方法。如果源程序的编码与当前默认 ANSI 编码不符，则需要使用 #pragma setlocale，告诉编译器源程序使用的编码：

以上需要注意 #pragma setlocale 与 setlocale(LC_ALL, "") 的作用是不同的，#pragma setlocale 在编译时起作用，setlocale() 在运行时起作用。

回页首

2.3 Java 中相关实现方法

字符串类 String 中的内容是 UNICODE 字符串：

字符串 I/O 操作，字符与字节转换操作。在 Java 包 java.io.* 中，以“Stream”结尾的类一般是用来操作“字节串”的类，以“Reader”，“Writer”结尾的类一般是用来操作“字符串”的类。

如果 java 的源程序编码与当前默认 ANSI 编码不符，则在编译的时候，需要指明一下源程序的编码。比如：

以上需要注意区分源程序的编码与 I/O 操作的编码，前者是在编译时起作用，后者是在运行时起作用。

回页首

3. 几种误解，以及乱码产生的原因和解决办法

3.1 容易产生的误解

第一种误解，往往是导致乱码产生的原因。第二种误解，往往导致本来容易纠正的乱码问题变得更复杂。

在这里，我们可以看到，其中所讲的“误解一”，即采用每“一个字节”就是“一个字符”的转化方法，实际上也就等同于采用 iso-8859-1 进行转化。因此，我们常常使用 bytes = string.getBytes("iso-8859-1") 来进行逆向操作，得到原始的“字节串”。然后再使用正确的 ANSI 编码，比如 string = new String(bytes, "GB2312")，来得到正确的“UNICODE 字符串”。

回页首

3.2 非 UNICODE 程序在不同语言环境间移植时的乱码

非 UNICODE 程序中的字符串，都是以某种 ANSI 编码形式存在的。如果程序运行时的语言环境与开发时的语言环境不同，将会导致 ANSI 字符串的显示失败。

比如，在日文环境下开发的非 UNICODE 的日文程序界面，拿到中文环境下运行时，界面上将显示乱码。如果这个日文程序界面改为采用 UNICODE 来记录字符串，那么当在中文环境下运行时，界面上将可以显示正常的日文。

由于客观原因，有时候我们必须在中文操作系统下运行非 UNICODE 的日文软件，这时我们可以采用一些工具，比如，南极星，AppLocale 等，暂时的模拟不同的语言环境。

回页首

3.3 网页提交字符串

当页面中的表单提交字符串时，首先把字符串按照当前页面的编码，转化成字节串。然后再将每个字节转化成 "%XX" 的格式提交到 Web 服务器。比如，一个编码为 GB2312 的页面，提交 "中" 这个字符串时，提交给服务器的内容为 "%D6%D0"。

在服务器端，Web 服务器把收到的 "%D6%D0" 转化成 [0xD6, 0xD0] 两个字节，然后再根据 GB2312 编码规则得到 "中" 字。

在 Tomcat 服务器中，request.getParameter() 得到乱码时，常常是因为前面提到的“误解一”造成的。默认情况下，当提交 "%D6%D0" 给 Tomcat 服务器时，request.getParameter() 将返回 [0x00D6, 0x00D0] 两个 UNICODE 字符，而不是返回一个 "中" 字符。因此，我们需要使用 bytes = string.getBytes("iso-8859-1") 得到原始的字节串，再用 string = new String(bytes, "GB2312") 重新得到正确的字符串 "中"。

回页首

3.4 从数据库读取字符串

通过数据库客户端（比如 ODBC 或 JDBC）从数据库服务器中读取字符串时，客户端需要从服务器获知所使用的 ANSI 编码。当数据库服务器发送字节流给客户端时，客户端负责将字节流按照正确的编码转化成 UNICODE 字符串。

如果从数据库读取字符串时得到乱码，而数据库中存放的数据又是正确的，那么往往还是因为前面提到的“误解一”造成的。解决的办法还是通过 string = new String( string.getBytes("iso-8859-1"), "GB2312") 的方法，重新得到原始的字节串，再重新使用正确的编码转化成字符串。

回页首

3.5 电子邮件中的字符串

当一段 Text 或者 HTML 通过电子邮件传送时，发送的内容首先通过一种指定的字符编码转化成“字节串”，然后再把“字节串”通过一种指定的传输编码（Content-Transfer-Encoding）进行转化得到另一串“字节串”。比如，打开一封电子邮件源代码，可以看到类似的内容：

最常用的 Content-Transfer-Encoding 有 Base64 和 Quoted-Printable 两种。在对二进制文件或者中文文本进行转化时，Base64 得到的“字节串”比 Quoted-Printable 更短。在对英文文本进行转化时，Quoted-Printable 得到的“字节串”比 Base64 更短。

邮件的标题，用了一种更简短的格式来标注“字符编码”和“传输编码”。比如，标题内容为 "中"，则在邮件源代码中表示为：

其中，

• 第一个“=?”与“?”中间的部分指定了字符编码，在这个例子中指定的是 GB2312。
• “?”与“?”中间的“B”代表 Base64。如果是“Q”则代表 Quoted-Printable。
• 最后“?”与“?=”之间的部分，就是经过 GB2312 转化成字节串，再经过 Base64 转化后的标题内容。

如果“传输编码”改为 Quoted-Printable，同样，如果标题内容为 "中"：

如果阅读邮件时出现乱码，一般是因为“字符编码”或“传输编码”指定有误，或者是没有指定。比如，有的发邮件组件在发送邮件时，标题 "中"：

这样的表示，实际上是明确指明了标题为 [0x00D6, 0x00D0]，即 "ÖÐ"，而不是 "中"。

回页首

4. 几种错误理解的纠正

误解：“ISO-8859-1 是国际编码？”

非也。iso-8859-1 只是单字节字符集中最简单的一种，也就是“字节编号”与“UNICODE 字符编号”一致的那种编码规则。当我们要把一个“字节串”转化成“字符串”，而又不知道它是哪一种 ANSI 编码时，先暂时地把“每一个字节”作为“一个字符”进行转化，不会造成信息丢失。然后再使用 bytes = string.getBytes("iso-8859-1") 的方法可恢复到原始的字节串。

误解：“Java 中，怎样知道某个字符串的内码？”

Java 中，字符串类 java.lang.String 处理的是 UNICODE 字符串，不是 ANSI 字符串。我们只需要把字符串作为“抽象的符号的串”来看待。因此不存在字符串的内码的问题。

某些网站允许软件开发社团通过发布开发者指南、白皮书、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提供的通用分析器是：
&#61548;        SimpleAnalyzer：用字符串标记一组单词并且转化为小写字母。
&#61548;        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，用于指定建立最佳索引。
&#61548;        Keyword字段是指不需要分析器解析但需要被编入索引并保存到索引中的部分。JavaSourceCodeIndexer类使用该字段来保存导入类的声明。
&#61548;        UnIndexed字段是既不被分析也不被索引，但是要被逐字逐句的将其值保存到索引中。由于我们一般要存储文件的位置但又很少用文件名作为关键字来搜索，所以用该字段来索引Java文件名。
&#61548;        UnStored字段和UnIndexed字段相反。该类型的Field要被分析并编入索引，但其值不会被保存到索引中。由于存储方法的全部源代码需要大量的空间。所以用UnStored字段来存储被索引的方法源代码。可以直接从Java源文件中取出方法的源代码，这样作可以控制我们的索引的大小。
&#61548;        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 】工作。

　#---JDBC ---输出到数据库
　　# JDBCAppender log4j.properties file
　　#log4j.rootCategory=WARN,JDBC
　　# APPENDER JDBC
　　log4j.appender.JDBC=org.apache.log4j.jdbc.JDBCAppender
　　log4j.appender.JDBC.driver=com.mysql.jdbc.Driver
　　log4j.appender.JDBC.URL=jdbc:mysql://localhost:3306/test
　　log4j.appender.JDBC.user=use
　　log4j.appender.JDBC.password=password
　　log4j.appender.JDBC.layout=org.apache.log4j.PatternLayout
　　log4j.appender.JDBC.sql=INSERT INTO LOGGING (log_date, log_level,
 location, message) VALUES ('%d{ISO8601}', '%-5p', '%C,%L', '%m')
　　
　　表结构如下：
　　
　　log_date　 varchar2(50)
　　log_level　varchar2(5)
　　location　 varchar2(100)
　　message　　varchar2(1000)
　　
　　笔者照做，但没有运行成功，而且此种方法是利用传统的数据库连接方法，对于数据库的
管理和效率严重不足，在现在这个连接池横行的时代,为什么我们不能给给Log4j配上连接池，
让Log4j利用数据连接池的连接和数据库进行通讯。现查看Log4j的Api,
log4j建议我们把其提供的JDBCAppender作为基类来使用，然后Override三个父类的方法：
getConnection(),closeConnection(Connection con)和
getLogStatement(LoggingEvent event)。
　　
　　原来如此，那就写一个子类JDBCPoolAppender来替代这个JDBCAppender
　　
　　JDBCPoolAppender代码和其相关代码如下：
　　
　　JDBCPoolAppender.java:
　　
　　package common.log;
　　import java.sql.Connection;
　　import org.apache.log4j.spi.LoggingEvent;
　　import java.sql.SQLException;
　　import java.sql.Statement;
　　import java.util.Iterator;
　　import org.apache.log4j.spi.ErrorCode;
　　import org.apache.log4j.PatternLayout;
　　import common.sql.MyDB;
　　import common.sql.GeneralDb;
　　
　　public class JDBCPoolAppender extends org.apache.log4j.jdbc.JDBCAppender {
　　
　　private MyDB mydb = null;
　　protected String sqlname=""; //增加一个数据库jndiName的属性
　　
　　protected Connection connection = null;
　　protected String sqlStatement = "";
　　/**
　　* size of LoggingEvent buffer before writting to the database.
　　* Default is 1.
　　*/
　　protected int bufferSize = 1;
　　
　　public JDBCPoolAppender() {
　　super();
　　}
　　
　　/**
　　* ArrayList holding the buffer of Logging Events.
　　*/
　　public void append(LoggingEvent event) {
　　buffer.add(event);
　　if (buffer.size() >= bufferSize)
　　flushBuffer();
　　}
　　
　　/**
　　* By default getLogStatement sends the event to the required Layout object.
　　* The layout will format the given pattern into a workable SQL string.
　　*
　　* Overriding this provides direct access to the LoggingEvent
　　* when constructing the logging statement.
　　*
　　*/
　　protected String getLogStatement(LoggingEvent event) {
　　return getLayout().format(event);
　　}
　　
　　/**
　　*
　　* Override this to provide an alertnate method of getting
　　* connections (such as caching).　One method to fix this is to open
　　* connections at the start of flushBuffer() and close them at the
　　* end.　I use a connection pool outside of JDBCAppender which is
　　* accessed in an override of this method.
　　* */
　　protected void execute(String sql) throws SQLException {
　　Connection con = null;
　　Statement stmt = null;
　　try {
　　con = getConnection();
　　stmt = con.createStatement();
　　stmt.executeUpdate(sql);
　　} catch (SQLException e) {
　　if (stmt != null)
　　stmt.close();
　　throw e;
　　}
　　stmt.close();
　　closeConnection(con);
　　//System.out.println("Execute: " + sql);
　　}
　　
　　/**
　　* Override this to return the connection to a pool, or to clean up the
　　* resource.
　　*
　　* The default behavior holds a single connection open until the appender
　　* is closed (typically when garbage collected).
　　*/
　　protected void closeConnection(Connection con) {
　　mydb=null;
　　try {
　　if (connection != null && !connection.isClosed())
　　connection.close();
　　} catch (SQLException e) {
　　errorHandler.error("Error closing connection", e,
　　ErrorCode.GENERIC_FAILURE);
　　}
　　
　　}
　　
　　/**
　　* Override 此函数来利用连接池返回一个Connetion对象
　　*
　　*/
　　protected Connection getConnection() throws SQLException {
　　try {
　　mydb = GeneralDb.getInstance(sqlname);
　　connection = mydb.getConnection();
　　} catch (Exception e) {
　　errorHandler.error("Error opening connection", e, ErrorCode.GENERIC_FAILURE);
　　}
　　return connection;
　　}
　　
　　/**
　　* Closes the appender, flushing the buffer first then closing the default
　　* connection if it is open.
　　*/
　　public void close() {
　　flushBuffer();
　　
　　try {
　　if (connection != null && !connection.isClosed())
　　connection.close();
　　} catch (SQLException e) {
　　errorHandler.error("Error closing connection", e,
　　ErrorCode.GENERIC_FAILURE);
　　}
　　this.closed = true;
　　}
　　
　　/**
　　* loops through the buffer of LoggingEvents, gets a
　　* sql string from getLogStatement() and sends it to execute().
　　* Errors are sent to the errorHandler.
　　*
　　* If a statement fails the LoggingEvent stays in the buffer!
　　*/
　　public void flushBuffer() {
　　//Do the actual logging
　　removes.ensureCapacity(buffer.size());
　　for (Iterator i = buffer.iterator(); i.hasNext(); ) {
　　try {
　　LoggingEvent logEvent = (LoggingEvent) i.next();
　　String sql = getLogStatement(logEvent);
　　execute(sql);
　　removes.add(logEvent);
　　} catch (SQLException e) {
　　errorHandler.error("Failed to excute sql", e,
　　ErrorCode.FLUSH_FAILURE);
　　}
　　}
　　
　　// remove from the buffer any events that were reported
　　buffer.removeAll(removes);
　　
　　// clear the buffer of reported events
　　removes.clear();
　　}
　　
　　/** closes the appender before disposal */
　　public void finalize() {
　　close();
　　}
　　
　　/**
　　* JDBCAppender requires a layout.
　　* */
　　public boolean requiresLayout() {
　　return true;
　　}
　　
　　/**
　　*
　　*/
　　public void setSql(String s) {
　　sqlStatement = s;
　　if (getLayout() == null) {
　　this.setLayout(new PatternLayout(s));
　　} else {
　　((PatternLayout) getLayout()).setConversionPattern(s);
　　}
　　}
　　
　　/**
　　* Returns pre-formated statement eg: insert into LogTable (msg) values ("%m")
　　*/
　　public String getSql() {
　　return sqlStatement;
　　}
　　
　　public void setSqlname(String sqlname){
　　sqlname=sqlname;
　　}
　　
　　public String getSqlname(){
　　return sqlname;
　　}
　　
　　public void setBufferSize(int newBufferSize) {
　　bufferSize = newBufferSize;
　　buffer.ensureCapacity(bufferSize);
　　removes.ensureCapacity(bufferSize);
　　}
　　
　　public int getBufferSize() {
　　return bufferSize;
　　}
　　}
　　
　　MyDB.java:
　　package common.sql;
　　import java.sql.*;
　　import com.codestudio.sql.*;　//引入开源项目Poolman数据库连接池的包
　　
　　public class MyDB {
　　public static final String module = MyDB.class.getName();
　　private String dbName = "";
　　private PoolMan plmn = null;
　　
　　public MyDB(String dbName) {
　　try {
　　if (plmn == null) {
　　plmn = (PoolMan) Class.forName("com.codestudio.sql.PoolMan").
　　newInstance();
　　}
　　} catch (Exception ec) {
　　System.out.println(ec.toString()+module);
　　}
　　this.dbName = dbName;
　　}
　　
　　private Connection getNewConnection() {
　　Connection conn = null;
　　try {
　　conn = plmn.connect("jdbc:poolman://" + dbName);
　　conn.setAutoCommit(true);
　　} catch (Exception ec) {
　　System.out.println(ec.toString()+"First:Connect sqlsever failed"+module);
　　try {
　　Thread.sleep(1000);
　　conn = plmn.connect("jdbc:poolman://" + dbName);
　　conn.setAutoCommit(true);
　　} catch (Exception ecs) {
　　System.out.println(ecs.toString()+"Again:Connect sqlsever faile"+module);
　　}
　　}
　　return conn;
　　}
　　
　　public Connection getConnection() {
　　return getNewConnection();
　　}
　　}
　　GeneralDb.java:
　　
　　package common.sql;
　　
　　package common.sql;
　　import java.util.*;
　　
　　public class GeneralDb {
　　private static Hashtable dbPool;
　　public static MyDB getInstance(String dbname) {
　　if (dbPool == null) {
　　dbPool = new Hashtable();
　　}
　　MyDB db = (MyDB) dbPool.get(dbname);
　　if (db == null) {
　　db = new MyDB(dbname);
　　dbPool.put(dbname, db);
　　}
　　return db;
　　}
　　}
　　
　　Log4j数据库连接池的配置如下：
　　log4j.appender.JDBC=common.log.JDBCPoolAppender
　　log4j.appender.JDBC.sqlname=log
　　log4j.appender.JDBC.layout=org.apache.log4j.PatternLayout
　　log4j.appender.JDBC.sql=INSERT INTO LOGGING (log_date, log_level, 
location, message) VALUES ('%d{ISO8601}', '%-5p', '%C,%L', '%m')
　　
　　poolman.xml配置如下：
　　
　　〈?xml version="1.0" encoding="UTF-8"?>
　　〈poolman>
　　〈management-mode>local〈/management-mode>
　　〈datasource>
　　〈dbname>log〈/dbname>
　　〈jndiName>log〈/jndiName>
　　〈driver>com.mysql.jdbc.Driver〈/driver>
　　〈url>jdbc:mysql://localhost:3306/test〈/url>
　　〈username>use〈/username>
　　〈password>password〈/password>
　　〈minimumSize>0〈/minimumSize>
　　〈maximumSize>10〈/maximumSize>
　　〈logFile>logs/mysql.log〈/logFile>
　　〈/datasource>　　
　　〈/poolman>

最近要从网页中提取信息，想先把html转换成标准的xml格式，然后方便使用dom4j进行后续的分析，试用了不少现成的类库，JTidy、NekoHTML、HTML Parser、Jericho，最后还是使用了JTidy。

只是r8 snapshot还只是一个nightly builds，前面的r7版更已经是4年前的事了，这个项目就这样荒废了？可能是参与的人太少又或者是觉得已经成熟？

JTidy提供了一个语法检查器和标签补偿器，能够对各种乱七八糟的html进行修复，使之符合xhtml标准。

r8 snapshot相对于r7改变了一些参数的设置方法，特别是在字符编码处理上，用setInputEncoding和setOutputEncoding方法来确定输入和输出文件的字符编码，可以使用任何有效的Java编码名称，这就比以前的强多了。

总体上解析的结果还不错，只是有些地方还需要对生成文件进行手工调整，或者自己再编一段代码处理一下，已经不是大问题了。

一些常用的参数设置：

setAltText(java.lang.String altText) 
加上默认的alt属性值
setBreakBeforeBR(boolean breakBeforeBR)
在换行<br />之前加一空行
setCharEncoding(int charencoding)
已废弃
setConfigurationFromFile(java.lang.String filename)
从文件中读取配置信息
setConfigurationFromProps(java.util.Properties props)
从properties中读取配置信息
setErrfile(java.lang.String errfile)
错误输出文件
setFixBackslash(boolean fixBackslash)
URL中用/取代\
setForceOutput(boolean forceOutput)
不管生成的xml是否有错，强制输出。
setHideComments(boolean hideComments) 
结果中不生成注释
setInputEncoding(java.lang.String encoding)
输入编码
setLogicalEmphasis(boolean logicalEmphasis)
用em替代i，strong替代b
setMessageListener(TidyMessageListener listener)
加入一个TidyMessageListener监听器
setOnlyErrors(boolean onlyErrors) 
只输出错误文件
setOutputEncoding(java.lang.String encoding) 
输出编码
setPrintBodyOnly(boolean bodyOnly) 
只输出body中的部分
setRepeatedAttributes(int repeatedAttributes) 
重复属性的处理
setSpaces(int spaces) 
每行前的空格数，就是缩进格式
setTidyMark(boolean tidyMark) 
是否生成tidy标记
setTrimEmptyElements(boolean trimEmpty) 
不输出空元素
setUpperCaseAttrs(boolean upperCaseAttrs) 
属性变大写
setUpperCaseTags(boolean upperCaseTags) 
标记变大写
setWraplen(int wraplen) 
多长换行
setXHTML(boolean xhtml) 
输出xhtml
setXmlOut(boolean xmlOut)
输出xml
setXmlPi(boolean xmlPi) 
文件头输出xml标记
setXmlSpace(boolean xmlSpace)
加入xml名字空间属性

使用方法极为easy，定义输入输出流，用tidy.parse()转换就行了：

BufferedInputStream in;

FileOutputStream out;

Tidy tidy = new Tidy();

tidy.setConfigurationFromFile(configFileName);//配置文件，写入上面的设置参数

try {

in = new BufferedInputStream(new FileInputStream(srcFileName));

out = new FileOutputStream(outFileName);

tidy.parse(in, out);

} catch (IOException e) {

System.out.println(e);

}