而在其它的编辑器中，默认保存的内容都是GB2312或者GBK（NOTEPAD中对应ANSI）.而根据前面所说的UTF-8和GBK,GB2312等的编码值是不同的这一点，可以知道，如果文件使用了UTF-8，那么字符编码就必须使用UTF-8，否则编码值的不同就可能造成乱码。而这也就是为什么那么多的人使用了UTF-8编码后还会产生乱码的根本原因。（JS和JSP都是这个道理）

3、JSP,STRUTS等的中文乱码解决方案
     其实解决的方法只有一个：

 request.setCharacterEncoding(encoding);

   方法只有一种，但处理方式就多种多样了，初学者会在JSP页面上直接使用，而有经验的程序员会使用过滤器。而现在所要说的方法也是过滤器。这里以统一使用UTF-8作为编码作为例子说明。具体过程就不多说了，网上有很多教程。偷懒一点的，到TOMCAT中复制就行了。在TOMCAT的目录下的\webapps\jsp-examples\WEB-INF\classes\filters\找到SetCharacterEncodingFilter.java 这个类，放到你的程序中并配置好映射路径。配置好后基本上你的乱码问题就解决了。但要映射路径中需要注意的就是不能使用 '*'

   < filter-mapping >
     < filter-name > Set Character Encoding </ filter-name >
     < servlet-name > * </ servlet-name >
   </ filter-mapping >

像上面这样配置的话(可能也是网上大多教程的做法，想当年也是害苦了我)，可能你只有JSP的乱码解决了，要解决STRUTS的乱码需要映射 *.do 或者 servletActionName。然后在初始化参数中设置encoding的值就行了。

< init-param >
       < param-name > encoding </ param-name >
       < param-value > UTF-8 </ param-value >
</ init-param >

当然，最重要的是要记得根据前面所说的方法，改变你所使用的编辑器保存文件的编码要与使用的字符编码一致。
而在JSP内容中，还是使用如网上教程所说的那种技俩，在所有页面的页首加入：

<% @ page language = "java" contentType = " text / html; charset = UTF - 8 "
    pageEncoding = "UTF - 8 " %>

xmlhttp.open( "post", url, async );
xmlhttp.setRequestHeader( "Content-Type", "text/html" );
xmlhttp.send( params );

通过前面的说明，不知道你现在看出端倪了没有。不知道是受了网上教程的影响还是其它方面影响，setRequestHeader并是万年不变的，也没人想过去改它，而问题就正好出在这个地方。回想一个JSP页面内容的编码设置，其中有这么一节：

contentType="text/html; charset=UTF-8"

现在知道问题了吧，所以我们要把第二句代码改为：

xmlhttp.setRequestHeader( "Content-Type", "text/html;charset=UTF-8" );

最后别忘了在返回数据时也设置上：

response.setContentType( "text/xml" );
response.setCharacterEncoding( "UTF-8" );

是不是很简单，一点都不麻烦呢？
如果要问为什么的话，其实我们可以把xmlhttp看成是一个临时页面，它由浏览器动态生成，主要作用是在后台获得请求的数据（可以看成是一个高级的iframe）。所以对于普通页面设置的编码，对它也要同样设置。而在servlet中返回数据为什么要设置contentType和encoding其道理也是一样的。众所周知，jsp的最后形态就是servlet，而jsp页首设置的那个内容其实也就是让生成的servlet中生成这么两句话：

response.setContentType( "text/html" );
response.setCharacterEncoding( "UTF-8" );

而pageEncoding则是跟jvm说明了这个页面的内容要使用什么编码保存（这跟之后生成的CLASS有关系）。所以在servlet设置response的编码也是理所当然的了。

一口气把自己一年以来遇到的乱码问题和解决的方案写出来了，希望对你有所帮助。

 contextLoader的源码
 public WebApplicationContext initWebApplicationContext(ServletContext servletContext)
   throws BeansException {

  long startTime = System.currentTimeMillis();
  if (logger.isInfoEnabled()) {
   logger.info("Root WebApplicationContext: initialization started");
  }
  servletContext.log("Loading Spring root WebApplicationContext");

  try {
   // Determine parent for root web application context, if any.
   ApplicationContext parent = loadParentContext(servletContext);

   WebApplicationContext wac = createWebApplicationContext(servletContext, parent);
   servletContext.setAttribute(
     WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, wac);

   if (logger.isInfoEnabled()) {
    logger.info("Using context class [" + wac.getClass().getName() +
      "] for root WebApplicationContext");
   }
   if (logger.isDebugEnabled()) {
    logger.debug("Published root WebApplicationContext [" + wac +
      "] as ServletContext attribute with name [" +
      WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE + "]");
   }

   if (logger.isInfoEnabled()) {
    long elapsedTime = System.currentTimeMillis() - startTime;
    logger.info("Root WebApplicationContext: initialization completed in " + elapsedTime + " ms");
   }

   return wac;
  }
  catch (RuntimeException ex) {
   logger.error("Context initialization failed", ex);
   servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
   throw ex;
  }
  catch (Error err) {
   logger.error("Context initialization failed", err);
   servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, err);
   throw err;
  }
 }
 注意WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE,这里面放了WebApplicationContext,需要使用时从ServletContext取出
 可以使用WebApplicationContextUtils得到WebApplicationContext
 public static WebApplicationContext getWebApplicationContext(ServletContext sc) {
  Object attr = sc.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
  if (attr == null) {
   return null;
  }
  if (attr instanceof RuntimeException) {
   throw (RuntimeException) attr;
  }
  if (attr instanceof Error) {
   throw (Error) attr;
  }
  if (!(attr instanceof WebApplicationContext)) {
   throw new IllegalStateException("Root context attribute is not of type WebApplicationContext: " + attr);
  }
  return (WebApplicationContext) attr;
 }
 关键的问题在于struts如何启动的spring的,ContextLoaderPlugIn的源码
 
 // Publish the context as a servlet context attribute.
  String attrName = getServletContextAttributeName();
  getServletContext().setAttribute(attrName, wac);
 
 public String getServletContextAttributeName() {
  return SERVLET_CONTEXT_PREFIX + getModulePrefix();
 }
 不同加载的Key竟然不同,原因就是WebApplicationContext放在那里的问题,可spring调用的时候会根据WebApplicationContext里面定义的那个名字去找的,问题出在这里

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

    <controller>
        <set-property property="processorClass" value="org.springframework.web.struts.DelegatingRequestProcessor" />
    </controller>

 原理是这样的,Struts虽然只能有一个ActionServlet实例,但是对于不同的子应用分别能有自己的RequestProcessor实例每个RequestProcessor实例分别对应不同的struts配置文件。
   子应用的ProcessorClass类必须重写一般就是继承RequestProcessor类，然后再其配置文件的controller元素中的<processorClass>属性中作出修改。那么当
  getRequestProcessor(getModuleConfig(request)).process(request,response);就能根据request选择相应的moduleconfig,再根据其<processorClass>属性选择相应的RequestProcessor子类来处理相应的请求了。

ServletContext 被 Servlet 程序用来与 Web 容器通信。例如写日志，转发请求。每一个 Web 应用程序含有一个Context，被Web应用内的各个程序共享。因为Context可以用来保存资源并且共享，所以我所知道的 ServletContext 的最大应用是Web缓存----把不经常更改的内容读入内存，所以服务器响应请求的时候就不需要进行慢速的磁盘I/O了。

import User; //my own class
import DatabaseManager; // my own class
import javax.servlet.ServletContext;
import javax.servlet.ServletContextListener;

public class MyContextListener

	implements ServletContextListener {
	private ServletContext context = null;

	public void contextInitialized(ServletContextEvent event) {
		context = event.getServletContext();
		User user = DatabaseManager.getUserById(1);
		context.setAttribute("user1", user);
	}

	public void contextDestroyed(ServletContextEvent event) {
		User user = (User)context.getAttribute("user1");
		DatabaseManager.updateUserData(user);
		this.context = null;
	}
}

<listener>
	<listener-class>MyServletContextListener</listener-class>
</listener>

图三 deploytool的启动画面

图四 新建一个Application

图五 将.class文件添加到SecurityJar中

图六 将ClientCode目录下的文件添加到SecurityJar中

图七 SecurityApp的JNDI Names标签页的设置

图八 SecurityApp的Web Context标签页的设置

图九 发布完成后的Deployment Progress

图十 运行效果第一个页面（加密/解密请求窗）


图十一 运行效果第二个页面（加密/解密结果显示页）

[概述]

Taglib是JSP比较高级的技术。做为JSP开发人员来讲，不了解taglib是可以接受的。因为JSP的风格或者JAVA的风格就是一种简洁的美。如果技术太过复杂或者繁琐，就会在技术的汪洋中失去自我。

但是，当我们的项目变得越来越大，或者团队有了一些技术积累之后，很自然就会有将我们的开发工作提高一个层次的需要。当我们面对一些非常类似的界面或者程序单元的时候，我们会想到把这样的工作成果直接用于下一个项目。这样的问题可以由taglib来解决。

到此还没有真正说明一下taglib是什么。只要你从事过JSP的开发工作，你就已经使用过taglib了。只不过是在不知不觉中使用的。你一定不会忘记 <jsp:include />标记。实际上这就是一个taglib。Taglib直译做标记库，是JSP定义给开发人员可以使用自行定义的标记体系。也就是说，开发人员可以在JSP中使用自己定义的特殊标记。而该标记可以用作特定的用途。比如显示一个每个页都需要的公司版权信息。就可以不用复制粘贴相同的代码到每个页去了。

但是taglib可以完成的工作远远不止这些。由于每个自定义标记一定是一个完全的JAVA类，我们可以定义非常丰富的一组行为，并且可以通过自定义的attribute来控制它。

[实例]

我习惯用实例来说明问题。大家也许都对用户会话状态的检查不陌生。当用户登录到系统后，我们希望自动保持用户的登录状态。而这个过程在每个需要认证用户才能访问的程序单元都需要实现。通常我们需要访问预定义的session服务器变量，当这个变量不满足某值时即判定改用户为非法访问或者会话状态丢失。

我们来看一下使用taglib如何实现。我们需要编写一个仅处理该逻辑的标记。实现的最简单的逻辑：检查用户状态session值，不满足某值时即将用户转向一个预先设置的报错页。

以下是源码(CheckSessionTag.java)：
(省略了细节)

public class CheckSessionTag extends TagSupport
{
    public  int  doEndTag()
    {
         try
        {
            String member_id  =  (String) pageContext.getSession().getAttribute( " member_id " );
             if (member_id  ==   null   ||  member_id.equals( "" ))
            {
                pageContext.forward( " /home/check_session_fail.jsp " );
            }
        }
         catch (Exception e)
        {
             //  报告异常过程省略.
        }
         return  EVAL_PAGE;
    }
}

[分析]

在以上源码中，我们在使tag自动检查用户session变量中的"member_id"值，如果该值为空，则立即判定用户没有访问权限，则立即将流程导向一个预先设定的报错页：/home/check_session_fail.jsp.

类CheckSessionTag派生自：TagSupport(javax.servlet.jsp.tagext.TagSupport). 是一个从JAVA 1.3就开始支持的类库，位于servlet.jar包。java文档给出的描述是：

A base class for defining new tag handlers implementing Tag. The TagSupport class is a utility class intended to be used as the base class for new tag handlers. The TagSupport class implements the Tag and IterationTag interfaces and adds additional convenience methods including getter methods for the properties in Tag. TagSupport has one static method that is included to facilitate coordination among cooperating tags. Many tag handlers will extend TagSupport and only redefine a few methods.
(该类为所有taglib的基类。该类定义了实现标记的一系列接口。)

在实例CheckSessionTag类中，我们仅仅重写了doEndTag方法。没有向其容器：jsp页输出任何东西。但是该类在实际应用中是切实可行的。

以下是在一个成品项目中的某jsp中截取的片断：
<logic:checkSession />

当我们直接使用输入url的方式访问本页时，我们被立即带到了报告：用户会话状态丢失或者未经登录的页。
这就省却了我们习以为常的一项工作：以前我们必须复制相同的scriplet到每个jsp页。（实际上，也可以使用类似intercept filter的模式来处理此需求）。这使我们的开发工作变得reusable, flexiable, 和extendable。可以想象，如果我们想改变检查session的逻辑，则可以仅仅通过改变CheckSessionTag内部的逻辑就可以通盘改变。并且我们可以通过给logic:checkSession标记加上类似target=admin的attribute来限定只有管理员才可以访问的区域。这就是形成组件化开发的基本过程。

如何实施呢?


[实施过程]

我们需要做一系列工作来将taglib引入我们的工程。

web.xml
为了使jsp解析器可以识别我们的taglib必须将其配置在web.xml内。web.xml位于/WEB-INF目录内。
使用特定语法来配置我们的taglib:
web.xml(片断)

< web-app >

     < taglib >
         < taglib-uri > /WEB-INF/logic.tld </ taglib-uri >
         < taglib-location > /WEB-INF/logic.tld </ taglib-location >
     </ taglib >

< web-app >

该语法告诉容器到什么地方去寻找所有logic:开头的tag.

tld是taglib defination的缩写。即taglib定义。该文件定义了我们使用的标记，Java类如何加载，并且该标记如何工作。让我们来看一段实际的tld:
logic.tld(片断)

<? xml version="1.0" encoding="ISO-8859-1" ?>
<! DOCTYPE taglib
     PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2/EN"
     "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd" >

< taglib >
     < tlib-version > 1.0 </ tlib-version >
     < jsp-version > 1.2 </ jsp-version >
     < short-name > logic </ short-name >
     < uri > /taglibs/logic </ uri >

     < tag >
        < name > checkSession </ name >
        < tag-class > mbajob.common.tags.logic.CheckSessionTag </ tag-class >
        < body-content > empty </ body-content >
     </ tag >

我们注意到taglib标记内.
1． short-name: 标记的prefix名。
2． uri: 识别该taglib的名称。

tag标记：
1． name: 标记名（prefix:之后）
2． tag-class：类名（包含包名）
3． body-content: 标记内容模式，如果该标记没有内容则为empty.

将logic.tld放置在/WEB-INF下，此时确保编译好的CheckSessionTag类可以被容器访问到。即可完成配置。必须注意的是，不同的jsp容器的配置可能有差别。本文的配置是基于Resin 2.1.11

[应用]

建立一个jsp页。在源码的开头加入如下的预编译指令：(page)
<%@ taglib prefix="logic" uri="/WEB-INF/logic.tld" %>

此指令告诉编译器到哪里去寻找所有以logic:开头的标记的定义。

接下来在任意位置加入标记：<logic:checkSession />即可以工作了。当标记被实例化后，即自动执行doEndTag过程，检查session服务器变量值，之后将页过程跳转。


[深入一些：attribute]

有时候我们希望可以对标记进行一些定制。依旧拿checkSession做例：现在我们要限制两类用户访问系统：某
些部分仅允许具有管理员权限的用户访问。这样我们设想可以在<logic:checkSession target=admin />进行进一步定义。这需要在CheckSessionTag类中增加一些额外的逻辑。检查的过程很简单，取决于你的安全系统的分析，但是，我们写了target attribute如何是类可以得到该数据，这是一个关键的问题。

为了实现对tag增加可用的attribute, 需要做如下工作：
1． 为类增加相应的成员及相应读写器：
CheckSessionTag.java(片断): 

public class CheckSessionTag extends TagSupport
{
     private String target;

     public  void  setTarget(String t)
     {
         this .target  =  t;
     }

     public String getTarget()
     {
         return   this .target;
     }

    public  int  doEndTag()
    {
        
    }

2． 更改logic.tld:

.

     < tag >
        < name > checkSession </ name >
        < tag-class > mbajob.common.tags.logic.CheckSessionTag </ tag-class >
        < body-content > empty </ body-content >
        < attribute >
           < name > title </ name >
           < required > true </ required >
        </ attribute >
     </ tag >

为tag标记增加arrtibute节点，语法如下：

name: attribute名
required: 是否为必须的attribute

幸运的是，jsp内置地将attribute解释为java类的成员，我们无需显式地获取该值，即可直接使用。也就是说，我们只要在tag内指定了target=admin, 那么，CheckSessionTag在活着的时候就自动获取该值，可以在逻辑中直接使用。

这样，我们就可以给tag增加任意的attribute.


[入门以后]

到此为止，我么就可以写一些类似的简单的tag了。根据不同的需求，完成不同的逻辑。当我们开发一个新的tag的时候，我们在logic.tld里增加一个tag子标记。设置好相应的类型。如果需要，我们可以把我们已经写好的tag们完全的移植到第二个项目中使用，仅仅做很少的更改。而更改也仅仅限于对java源代码。

在我和我的团队的实际经验中，taglib最多的应用还是在设计一系列特殊的UI. 例如类似于选择省市多级行政区域的选择器。为了放置在HTML中嵌入过多scriplet和脚本，我们的做法通常是将其写在组装好的tag里；为了形成整个应用一致的外观，我们设计了一套用于组装页构图的框架；为了向jsp输出集合数据，我们设计了可以绑定数据的呈现器。经过很长一个时期的工作，我们发现我们的项目中jsp页内仅有很少的html, 而完全是有taglib组成的。最终，我们的taglib按照layout, logic, element, form分类，已经形成了比较大的规模。我们甚至完成了apache的struts框架完成的一部分工作。甚至做得更灵活。所有这些工作中积累的思想甚至影响到我在.NET平台下的技术思路。

为了不使篇幅太长，我不准备在本文再做深入的探索。仅仅介绍taglib入门级的一些东西。有时间的话，可能会再次写一些高级一些的taglib的设计方法。


[与ASP.NET Web Custom Control]

不能说taglib与ASP.NET Web Custom Control有什么可比性。但是我习惯将二者放到一起看。因为因为在某些实际项目中，我确实从二者之间找到一些共性。甚至有时候创作一些组件的时候实现是完全相同的。
1． 二者都定义了当标记输出开始标记和结束标记时的过程。
2． 二者都可以跨应用使用。
3． 可以使用相同的HTML和脚本。

但比较起来，ASP.NET Web Custom Control更高级一些。可以在容器中直接以对象的形式访问。并且可以定义方法，事件。意即可以完全控制一个控件。

而taglib同样有优点，例如可以嵌套使用，开发成本低等。最关键的是，taglib具有做为java产品的精细，小巧和活泼。他们分别是有着不同风格的优秀技术。

参考文档
taglib最佳实践(IBM developerWorks中文站)
http://www-900.ibm.com/developerWorks/cn/java/j-jsp07233/

肖菁，软件工程师，IBM developerWorks/Bea dev2dev/sun 技术开发者撰稿人，主要研究J2EE、web services以及他们在websphere、weblogic平台上的实现，拥有IBM的 Developing With Websphere Studio证书。您可以通过guilaida@163.com和作者取得联系，或者查看作者的主页获取更多信息。

文章摘要

Cache是一种用于提高系统响应速度、改善系统运行性能的技术。尤其是在Web应用中，通过缓存页面的输出结果，可以很显著的改善系统运行性能。本文中作者给大家介绍一个实现J2EE框架中Web应用层缓存功能的开放源代码项目----OSCache。通过应用OSCache，我们不但可以实现通常的Cache功能，还能够改善系统的稳定性。

1 面临的问题

1.1 需要处理的特殊动态内容

在信息系统建设过程中我们通常会遇到这样的问题：

1. 基础数据的变更问题

信息系统中需要处理的基础数据的内容短时间内是不会发生变化的，但是在一个相对长一些的时间里，它却可能是动态增加或者减少的。

举个例子：电子商务中关于送货区域的定义，可能短时间内不会发生变化，但是随着电子商务企业业务的扩大，系统中需要处理的送货区域就可能增加。所以我们的系统中不得不在每次向客户展示送货区域信息的时候都和数据库（假设送货区域信息保存在数据库中，这也是通常采用的处理方法）进行交互。

2. 统计报表（不仅限于统计报表）的问题

一般来说，统计报表是一个周期性的工作，可能是半个月、一个月或者更长的时间才会需要更新一次，然而统计报表通常是图形显示或者是生成pdf、word、excel等格式的文件，这些图形内容、文件的生成通常需要消耗很多的系统资源，给系统运行造成很大的负担。

1.2 问题的共同点

通过比较分析，不难发现这两类问题有一些共同点：

1、被处理的内容短时间不变，所以短时间内可以作为静态内容进行处理

2、在一个不太长的时间内，被处理的内容可能或者必定产生变化，所以必须将他们作为动态内容进行处理

3、在合理的时间区段内可以忽略被处理内容变化后带来的影响

4、对这些内容的处理动作比较消耗系统性能，影响系统响应时间

1.3 解决方法

缓存技术可以帮助我们很好的解决这个问题：

1、缓存信息

当上述的基础数据或者统计报表第一次被访问时，被处理的内容被当作动态信息，基础数库从数据库中获得，统计报表也会被生成符合要求的图形、文件，然后这些信息都会被放入缓存信息中。

2、响应信息由缓存提供

当上述的基础数据或者统计报表继续被访问时，系统将会首先检查缓存信息中是否有对应的内容和我们设定的缓存规则，如果符合缓存信息存在而且符合缓存规则，给出的响应将来自于缓存信息，如果没有或者缓存信息已经不符合设定的要求，系统将重复上一步的动作。

很显然，上面的步骤2中，多数情况下，当用户请求到达时，被处理的内容将来自于缓存，所以大大的减少了与数据库的交互，或者不再需要为每个请求都生成一次报表图形或者文件，这部分工作的减少对于降低系统性能消耗、提高系统稳定性和并发处理能力是非常有益的。

2 OSCache简介

OSCache是OpenSymphony组织提供的一个J2EE架构中Web应用层的缓存技术实现组件，它的出现解决了我们面临的问题。 OSCache目前最新的稳定版本是2.0，本文中的例子都是基于这个版本的，如果大家运行例子的过程中发生问题，请首先确认是否采用了正确的软件版本。

2.1 主要特征

1. 兼容多种支持JSP的web服务器

已经通过兼容测试的web服务器包括OrionServer (1.4.0或者以上版本) 、Macromedia JRun (3.0或者以上版本) 、BEA Weblogic (7.x或者以上版本) 、IBM Websphere (5.0版本)、Silverstream (3.7.4版本)、Caucho Resin (1.2.3或者以上版本)、Tomcat (4.0或者以上版本) ，其他支持servlet2.3、jsp1.2的web服务器应该都是完全兼容OSCache的。

2. 可选的缓存区

你可以使用内存、硬盘空间、同时使用内存和硬盘或者提供自己的其他资源（需要自己提供适配器）作为缓存区。

• 使用内存作为缓存区将可以提供更好的性能
• 使用硬盘作为缓存区可以在服务器重起后迅速恢复缓存内容
• 同时使用内存和硬盘作为缓存区则可以减少对内存的占用

3. 灵活的缓存系统

OSCache支持对部分页面内容或者对页面级的响应内容进行缓存，编程者可以根据不同的需求、不同的环境选择不同的缓存级别。

4. 容错

在一般的web应用中，如果某个页面需要和数据库打交道，而当客户请求到达时，web应用和数据库之间无法进行交互，那么将返回给用户"系统出错"或者类似的提示信息，如果使用了OSCache的话，你可以使用缓存提供给用户，给自己赢得维护系统或者采取其他补救的时间。

其它特性还包括对集群的支持、缓存主动刷新等特性，大家可以参考OpenSymphony网站上的其他资源获取更多的信息。

3 OSCache组件的安装

OSCache是一个基于web应用的组件，他的安装工作主要是对web应用进行配置，大概的步骤如下：

1. 下载、解压缩OSCache

请到OSCache的主页http://www.opensymphony.com/oscache/download.html下载Oscache的最新版本，作者下载的是OSCache的最新稳定版本2.0。

将下载后的。Zip文件解压缩到c:\oscache（后面的章节中将使用%OSCache_Home%来表示这个目录）目录下

2. 新建立一个web应用

3. 将主要组件%OSCache_Home%\oscache.jar放入WEB-INF\lib目录

4. commons-logging.jar、commons-collections.jar的处理

• OSCache组件用Jakarta Commons Logging来处理日志信息，所以需要commons-logging.jar的支持，请将%OSCache_Home%\lib\core\commons-logging.jar放入classpath（通常意味着将这个文件放入WEB-INF\lib目录）
• 如果使用JDK1.3,请将%OSCache_Home%\lib\core\commons-collections.jar放入classpath，如果使用JDK1.4或者以上版本，则不需要了

5. 将oscache.properties、oscache.tld放入WEB-INF\class目录

• %OSCache_Home%\oscache.properties包含了对OSCache运行特征值的设置信息
• %OSCache_Home%\oscache.tld包含了OSCache提供的标签库的定义内容

6. 修改web.xml文件

在web.xml文件中增加下面的内容，增加对OSCache提供的taglib的支持：

<taglib>
<taglib-uri>oscache</taglib-uri>
<taglib-location>/WEB-INF/classes/ oscache.tld</taglib-location>
</taglib> 

4 开始使用OSCache中的缓存组件

OSCache中按照缓存范围的不同分为两种不同的方式：一种是缓存JSP页面中部分或者全部内容，一种是基于整个页面文件的缓存。

4.1 JSP部分内容缓存

4.1.1 Cache-OSCache提供的缓存标签

这是OSCache提供的标签库中最重要的一个标签，包括在标签中的内容将应用缓存机制进行处理，处理的方式将取决于编程者对cache标签属性的设置。

第一次请求到达时，标签中的内容被处理并且缓存起来，当下一个请求到达时，缓存系统会检查这部分内容的缓存是否已经失效，主要是以下几项：

• 1. 缓存时间超过了cache标签设置的time或者duration属性规定的超时时间
• 2. cron属性规定的时间比缓存信息的开始时间更晚
• 3. 标签中缓存的内容在缓存后又被重新刷新过
• 4. 其他缓存超期设定

如果符合上面四项中的任何一项，被缓存的内容视为已经失效，这时被缓存的内容将被重新处理并且返回处理过后的信息，如果被缓存的内容没有失效，那么返回给用户的将是缓存中的信息。

cache标签的属性说明:

key - 标识缓存内容的关键词。在指定的作用范围内必须是唯一的。默认的key是被访问页面的URI和后面的请求字符串。

你可以在同一个页面中使用很多cache标签而不指定他的key属性，这种情况下系统使用该页面的URI和后面的请求字符串，另外再自动给这些key增加一个索引值来区分这些缓存内容。但是不推荐采用这样的方式。

scope - 缓存发生作用的范围，可以是application或者session

time - 缓存内容的时间段，单位是秒，默认是3600秒，也就是一个小时，如果设定一个负值，那么这部分被缓存的内容将永远不过期。

duration - 指定缓存内容失效的时间，是相对time的另一个选择，可以使用简单日期格式或者符合USO-8601的日期格式。如：duration='PT5M' duration='5s'等

refresh - false 或者true。

如果refresh属性设置为true，不管其他的属性是否符合条件，这部分被缓存的内容都将被更新，这给编程者一种选择，决定什么时候必须刷新。

mode - 如果编程者不希望被缓存的内容增加到给用户的响应中，可以设置mode属性为"silent"

其它可用的属性还包括：cron 、groups、language、refreshpolicyclass、refreshpolicyparam。

上面的这些属性可以单独使用，也可以根据需要组合使用，下面的例子将讲解这些常用属性的使用方式。

4.1.2 Cache标签实例分析:

1. 最简单的cache标签用法

使用默认的关键字来标识cache内容，超时时间是默认的3600秒

<cache:cache>
<%
//自己的JSP代码内容
%>
</cache:cache> 

2. 用自己指定的字符串标识缓存内容，并且设定作用范围为session。

<cache:cache key="foobar" scope="session">
<%
//自己的JSP代码内容
%>
</cache:cache> 

3.动态设定key值，使用自己指定的time属性设定缓存内容的超时时间，使用动态refresh值决定是否强制内容刷新。

因为OSCache使用key值来标识缓存内容，使用相同的key值将会被认为使用相同的的缓存内容，所以使用动态的key值可以自由的根据不同的角色、不同的要求决定使用不同的缓存内容。

<cache:cache key="<%= product.getId() %>" time="1800" refresh="<%= needRefresh %>">
<%
//自己的JSP代码内容
%>
</cache:cache> 

4. 设置time属性为负数使缓存内容永不过期

<cache:cache time="-1">
<%
//自己的JSP代码内容
%>

5. 使用duration属性设置超期时间

<cache:cache  duration='PT5M'>
<%
//自己的JSP代码内容
%>

6. 使用mode属性使被缓存的内容不加入给客户的响应中

<cache:cache  mode='silent'>
<%
//自己的JSP代码内容
%>

4.2 用CashFilter实现页面级缓存

在OSCache组件中提供了一个CacheFilter用于实现页面级的缓存，主要用于对web应用中的某些动态页面进行缓存，尤其是那些需要生成pdf格式文件/报表、图片文件等的页面，不仅减少了数据库的交互、减少数据库服务器的压力，而且对于减少web服务器的性能消耗有很显著的效果。

这种功能的实现是通过在web.xml中进行配置来决定缓存哪一个或者一组页面，而且还可以设置缓存的相关属性，这种基于配置文件的实现方式对于J2EE来说应该是一种标准的实现方式了。

[注] 只有客户访问时返回http头信息中代码为200（也就是访问已经成功）的页面信息才能够被缓存

1. 缓存单个文件

修改web.xml，增加如下内容，确定对/testContent.jsp页面进行缓存。

<filter>
      <filter-name>CacheFilter</filter-name>
<filter-class>com.opensymphony.oscache.web.filter.CacheFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>CacheFilter</filter-name>
<!-对/testContent.jsp页面内容进行缓存-->
      <url-pattern>/testContent.jsp</url-pattern>
</filter-mapping>

2. 缓存URL pattern

修改web.xml，增加如下内容，确定对*.jsp页面进行缓存。

<filter>
      <filter-name>CacheFilter</filter-name>
<filter-class>com.opensymphony.oscache.web.filter.CacheFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>CacheFilter</filter-name>
<!-对所有jsp页面内容进行缓存-->
      <url-pattern>*.jsp</url-pattern>
</filter-mapping>

3. 自己设定缓存属性

在页面级缓存的情况下，可以通过设置CacheFilter的初始属性来决定缓存的一些特性：time属性设置缓存的时间段，默认为3600秒，可以根据自己的需要只有的设置，而scope属性设置，默认为application，可选项包括application、session

<filter>
      <filter-name>CacheFilter</filter-name>
<filter-class>com.opensymphony.oscache.web.filter.CacheFilter</filter-class>
	<init-param>
         <param-name>time</param-name>
         <param-value>600</param-value>
      </init-param>
      <init-param>
         <param-name>scope</param-name>
         <param-value>session</param-value>
      </init-param>
</filter>
<filter-mapping>
<filter-name>CacheFilter</filter-name>
<!-对所有jsp页面内容进行缓存-->
<url-pattern>*.jsp</url-pattern>
</filter-mapping>

5 性能测试结果

5.1 测试环境

系统平台：windows 2000 高级服务器/ P3 800 /512M内存

web服务器：websphere 5.0

数据库服务器：mysql 4.0.18-nt

性能测试用工具：apache Jmeter

5.2 测试计划

这次性能测试对比方为使用缓存和不使用缓存两种，他们的访问代码都是一样的：通过数据源从本地mysql数据库中获取person表的所有记录，然后显示在页面上。

测试中将模仿10个用户，每个用户发起5次请求，然后统计所有访问花费的时间。

5.3 测试结果

使用缓存后的测试结果 不使用缓存时的测试结果

所有请求花费的总时间(毫秒) 20569 22870

性能测试的详细结果请大家查看下载内容中的《不使用cache时的系统性能测试结果.txt》和《使用cache后系统性能测试结果.txt》

6 总结

在J2EE系统中，我们经常需要处理一些特殊的动态内容，这些内容在一个时间段内的变更非常有限，但是又不得不将他们确定为动态内容进行输出，而且非常消耗数据库系统资源或者web服务器的资源，这时我们就可以采用Cache----一种用于提高系统响应速度、改善系统运行性能的技术----来优化我们的系统。尤其是在Web应用中，这种处理可以很显著的改善系统运行性能。

本文中作者给大家介绍一个实现J2EE框架中Web应用层缓存功能的开放源代码项目----OSCache。它提供了在J2EE系统中实现缓存需要的丰富的功能。通过应用OSCache，我们不但可以实现通常的Cache功能、自由的设定cache的相关特性比如缓存时间段/缓存内容等，提升系统性能，而且还能有效的改善系统的稳定性。除此之外，OSCache组件还提供了更多的特性比如集群、容错、灵活的缓存区选择等。

作者根据自己的使用经验给大家提供了一些简单的例子，他们部分演示了如何使用OSCache组件提供的丰富特性，OSCache提供的特性远不止这些，需要大家在今后的时间里深入的研究，同时也希望大家通过E-mail和作者贡献研究成果。

○用二分钟配置：

将下载的oscache-2.1.1-full.zip解压，你会看到oscache-2.1.1.jar 及一些目录 docs、etc、lib、src。
现在将 etc目录下oscache.properties 、oscache.tld 及 oscache-2.1.1.jar 文件复制到你的应用服务器目录下

使用tomcat，jdk1.4 配置例：
         D:\Tomcat 5.0\webapps\ROOT\WEB-INF\lib\oscache-2.1.1.jar
         D:\Tomcat 5.0\webapps\ROOT\WEB-INF\classes\oscache.properties
         D:\Tomcat 5.0\webapps\ROOT\WEB-INF\classes\oscache.tld

oscache.properties 文件配置参数说明：
cache.memory
值为true 或 false ，默认为在内存中作缓存，
如设置为false，那cache只能缓存到数据库或硬盘中，那cache还有什么意义：）
cache.capacity
缓存元素个数
cache.persistence.class
持久化缓存类，如此类打开，则必须设置cache.path信息
cache.cluster 相关
为集群设置信息。如
cache.cluster.multicast.ip为广播IP地址
cache.cluster.properties为集群属性

再将 D:\Tomcat 5.0\webapps\ROOT\WEB-INF\web.xml 文件中添加如下代码
<taglib>
<taglib-uri>oscache</taglib-uri>
<taglib-location>/WEB-INF/classes/oscache.tld</taglib-location>
</taglib>

就是这么简单，OSCache就配置好了。

○再用二分钟测试一下：

编写jsp文件
======================cache1.jsp 内容如下=================
<%@ page contentType="text/html;charset=GBK"%>
<%@ page import="java.util.*" %>
<%@ taglib uri="oscache" prefix="cache" %>
<html>
<body>
没有缓存的日期: <%= new Date() %><p>
<!--自动刷新-->
<cache:cache time="30">
每30秒刷新缓存一次的日期: <%= new Date() %> <p>
</cache:cache>

<!--手动刷新-->
<cache:cache key="testcache">
手动刷新缓存的日期: <%= new Date() %> <p>
</cache:cache>
<a href="http://dev.csdn.net/article/"cache2.jsp">手动刷新</a></body>
</html>
=========================================================

====================cache2.jsp 执行手动刷新页面如下===========
<%@ page contentType="text/html;charset=GBK"%>
<%@ taglib uri="oscache" prefix="cache" %>
<html>
<body>缓存已刷新...<p>

<cache:flush key="testcache" scope="application"/>

<a href="http://dev.csdn.net/article/"cache1.jsp">返回</a></body>
</html>
==========================================================       

其他： 缓存过滤器 CacheFilter
可以让你所有.jsp页面自动缓存。

你可以在web.xml中定义缓存过滤器，定义特定资源的缓存。
<filter>
<filter-name>CacheFilter</filter-name>
<filter-class>com.opensymphony.oscache.web.filter.CacheFilter</filter-class>
<init-param>
<param-name>time</param-name>
<param-value>60</param-value>
</init-param>
<init-param>
<param-name>scope</param-name>
<param-value>session</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>CacheFilter</filter-name>
<url-pattern>*.jsp</url-pattern>
</filter-mapping>
上面定义将缓存所有.jsp页面，缓存刷新时间为60秒，缓存作用域为Session

注意，CacheFilter只捕获Http头为200的页面请求，即只对无错误请求作缓存，
而不对其他请求（如500,404,400）作缓存处理

此文完。。谢谢观看。

1、POJO 缓存
这种方式的缓存直接调用OSCache的API进行，主要用于处理页面内容会根据参数动态改变，可以将参数设置为key值来保存数据：
首先，声明成员变量：
 // OSCache Adminitrator instance
 private static GeneralCacheAdministrator cacheAdmin = null;
其次，进行初始化：
 public RingArtistAction() {
  cacheAdmin = new GeneralCacheAdministrator();
 }
将POJO进行缓存：
  // Cache data key and refresh period
  String key = sex + ":" + place;
  int refreshPeriod = Constants.getIntegerValue(Constants.OSCACHE_REFRESH_PERIOD).intValue();
  try {
      // Get from the cache
   artists = (Map) cacheAdmin.getFromCache(key, refreshPeriod);
  } catch (NeedsRefreshException nre) {
      try {
          // Get the value (probably from the database)
    int count = getArtistCount(sex, place, errors);
    artists = getArtistData(sex, place, count, errors);
          // Store in the cache
    cacheAdmin.putInCache(key, artists);
      } catch (Exception ex) {
          // We have the current content if we want fail-over.
    artists = (Map) nre.getCacheContent();
          // It is essential that cancelUpdate is called if the
          // cached content is not rebuilt
    cacheAdmin.cancelUpdate(key);
    ex.printStackTrace();
      }
  }
 
2、HTTP Response 缓存
这种方式的缓存用来处理整个页面的内容固定，不会根据参数动态改变：
首先在web.xml中配置CacheFilter：
 <filter>
  <filter-name>CacheFilter</filter-name>
  <filter-class>com.opensymphony.oscache.web.filter.CacheFilter</filter-class>
  <init-param>
   <param-name>time</param-name>
   <param-value>86400</param-value>
  </init-param>
  <init-param>
   <param-name>scope</param-name>
   <param-value>application</param-value>
  </init-param>
 </filter>
将所有需要缓存的页面加入filter-mapping：
 <filter-mapping>
  <filter-name>Set Character Encoding</filter-name>
  <url-pattern>/*</url-pattern>
 </filter-mapping>
注意，只有返回状态为200（HttpServletResponse.SC_OK）的内容才会被缓存

3、JSP Tag 缓存
JSP Tag缓存主要用于缓存JSP页面的局部内容：
  <cache:cache key="especialcategory" cron="* 5 * * *">
  <jsp:include page="/ringcategory.do" flush="true" >
    <jsp:param name="ringType" value="1"/>
  </jsp:include>
  </cache:cache>

4、O/R Data Access 缓存
请阅读参考资料的内容获取详情。

参考资料：
Taking the load off: OSCache helps databases cope：http://www.theserverside.com/articles/article.tss?l=OSCacheHelpsDatabases

Java/JSP中文乱码问题解决心得

作者信息：liqian  liqianbnu@126.com   http://202.112.88.39/liqian/
文章原始出处：http://202.112.88.39/liqian/000271.html

自从接触Java和JSP以来，就不断与Java的中文乱码问题打交道，现在终于得到了彻底的解决，现将我们的解决心得与大家共享。

一、Java中文问题的由来

Java的内核和class文件是基于unicode的，这使Java程序具有良好的跨平台性，但也带来了一些中文乱码问题的麻烦。原因主要有两方面，Java和JSP文件本身编译时产生的乱码问题和Java程序于其他媒介交互产生的乱码问题。

首先Java（包括JSP）源文件中很可能包含有中文，而Java和JSP源文件的保存方式是基于字节流的，如果Java和JSP编译成class文件过程中，使用的编码方式与源文件的编码不一致，就会出现乱码。基于这种乱码，建议在Java文件中尽量不要写中文（注释部分不参与编译，写中文没关系），如果必须写的话，尽量手动带参数－ecoding GBK或－ecoding gb2312编译；对于JSP，在文件头加上<%@ page contentType="text/html;charset=GBK"%>或<%@ page contentType="text/html;charset=gb2312"%>基本上就能解决这类乱码问题。

本文要重点讨论的是第二类乱码，即Java程序与其他存储媒介交互时产生的乱码。很多存储媒介，如数据库，文件，流等的存储方式都是基于字节流的，Java程序与这些媒介交互时就会发生字符(char)与字节(byte)之间的转换，具体情况如下：

从页面form提交数据到java程序 byte－>char
从java程序到页面显示 char—>byte

从数据库到java程序 byte—>char
从java程序到数据库 char—>byte

从文件到java程序 byte－>char
从java程序到文件 char－>byte

从流到java程序 byte－>char
从java程序到流 char－>byte

如果在以上转换过程中使用的编码方式与字节原有的编码不一致，很可能就会出现乱码。

二、解决方法

前面已经提到了Java程序与其他媒介交互时字符和字节的转换过程，如果这些转换过程中容易产生乱码。解决这些乱码问题的关键在于确保转换时使用的编码方式与字节原有的编码方式保持一致，下面分别论述（Java或JSP自身产生的乱码请参看第一部分）。

1、JSP与页面参数之间的乱码
JSP获取页面参数时一般采用系统默认的编码方式，如果页面参数的编码类型和系统默认的编码类型不一致，很可能就会出现乱码。解决这类乱码问题的基本方法是在页面获取参数之前，强制指定request获取参数的编码方式：request.setCharacterEncoding("GBK")或request.setCharacterEncoding("gb2312")。
如果在JSP将变量输出到页面时出现了乱码，可以通过设置response.setContentType("text/html;charset=GBK")或response.setContentType("text/html;charset=gb2312")解决。
如果不想在每个文件里都写这样两句话，更简洁的办法是使用Servlet规范中的过虑器指定编码，过滤器的在web.xml中的典型配置和主要代码如下：
web.xml:

<filter>
<filter-name>CharacterEncodingFilter</filter-name>
<filter-class>net.vschool.web.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>GBK</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>CharacterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

CharacterEncodingFilter.java:

public class CharacterEncodingFilter implements Filter
{

protected String encoding = null;

public void init(FilterConfig filterConfig) throws ServletException
{
this.encoding = filterConfig.getInitParameter("encoding");
}

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException
{
request.setCharacterEncoding(encoding);
response.setContentType("text/html;charset="+encoding);
chain.doFilter(request, response);
}

}

2、Java与数据库之间的乱码
大部分数据库都支持以unicode编码方式，所以解决Java与数据库之间的乱码问题比较明智的方式是直接使用unicode编码与数据库交互。很多数据库驱动自动支持unicode，如Microsoft的SQLServer驱动。其他大部分数据库驱动，可以在驱动的url参数中指定，如如mm的mysql驱动：jdbc:mysql://localhost/WEBCLDB?useUnicode=true&characterEncoding=GBK。

3、Java与文件/流之间的乱码
Java读写文件最常用的类是FileInputStream/FileOutputStream和FileReader/FileWriter。其中FileInputStream和FileOutputStream是基于字节流的，常用于读写二进制文件。读写字符文件建议使用基于字符的FileReader和FileWriter，省去了字节与字符之间的转换。但这两个类的构造函数默认使用系统的编码方式，如果文件内容与系统编码方式不一致，可能会出现乱码。在这种情况下，建议使用FileReader和FileWriter的父类：InputStreamReader/OutputStreamWriter，它们也是基于字符的，但在构造函数中可以指定编码类型：InputStreamReader(InputStream in, Charset cs) 和OutputStreamWriter(OutputStream out, Charset cs)。

4、其他
上面提到的方法应该能解决大部分乱码问题，如果在其他地方还出现乱码，可能需要手动修改代码。解决Java乱码问题的关键在于在字节与字符的转换过程中，你必须知道原来字节或转换后的字节的编码方式，转换时采用的编码必须与这个编码方式保持一致。我们以前使用Resin服务器，使用smartUpload组件上传文件，上传文件同时传递的中文参数获取没有乱码问题。当在Linux中把Resin设置成服务后，上传文件同时的中文参数获取出现了乱码。这个问题困扰了我们很久，后来我们分析smartUpload组件的源文件，因为文件上传采用的是字节流的方式，里面包含的参数名称和值也是字节流的方式传递的。smartUpload组件读取字节流后再将参数名称和值从字节流中解析出来，问题就出现在smartUpload将字节流转换成字符串时采用了系统默认的编码，而将Resin设置成服务后，系统默认的编码可能发生了改变，因此出现了乱码。后来，我们更改了smartUpload的源文件，增加了一个属性charset和setCharset(String)方法，将upload()方法中提取参数语句：
String value = new String(m_binArray, m_startData, (m_endData - m_startData) + 1 );
改成了
String value = new String(m_binArray, m_startData, (m_endData - m_startData) + 1, charset );
终于解决了这个乱码问题。

三、后记
接触Java和JSP已经有一年多了，这一年来最大的收获是越来越喜欢上了Java，开始把问题当作乐事去研究，没有了以前的恐惧心理，我相信我会继续坚持下去。这一年来，从网上学习了很多同行的宝贵经验，在此表示感谢。这是我第一篇自己总结的Java学习心得，由于水平有限，本文中偏颇和错误之处，欢迎指正。如果对你有些价值，在保留作者信息和文章原始出处的前提下可以随处转载。
撰写该文之前已参考了很多关于Java中文问题的文章，其中影响比较大的有owen1944在“Java研究组织”中发表的《这是我们公司总结的一些关于中文乱码问题的一些解决方案和经验和大家分享！》等。本文谈到的解决方法已应用到“基于网络的协作学习系统－WebCL”等项目中，并通过资源绑定的方式实现了该平台中文文两个版本的即时切换。Google根据浏览器自动选择语言，一个页面同时显示多种语言的国际化应用和车东的《Java中文处理学习笔记——Hello Unicode》一文引起了我极大的兴趣，日后想将继续探讨Java的国际化问题，欢迎大家一起讨论。

1、 获取字符串的长度：length()
2、判断字符串的前缀或后缀与已知字符串是否相同
前缀 startsWith(String s)、后缀 endsWith(String s)
3、比较两个字符串：equals(String s)
4、把字符串转化为相应的数值
int型 Integer.parseInt(字符串)、long型 Long.parseLong(字符串)
float型 Folat.valueOf(字符串).floatValue()
double型 Double.valueOf(字符串).doubleValue()
5、 将数值转化为字符串：valueOf(数值)
6、 字符串检索
indexOf(Srting s) 从头开始检索
indexOf(String s ,int startpoint) 从startpoint处开始检索
如果没有检索到，将返回-1
7、 得到字符串的子字符串
substring(int startpoint) 从startpoint处开始获取
substring(int start,int end) 从start到end中间的字符
8、 替换字符串中的字符,去掉字符串前后空格
replace(char old,char new) 用new替换old
9、 分析字符串
StringTokenizer(String s) 构造一个分析器，使用默认分隔字符（空格，换行，回车，Tab，进纸符）
StringTokenizer(String s,String delim) delim是自己定义的分隔符
nextToken() 逐个获取字符串中的语言符号
boolean hasMoreTokens() 只要字符串还有语言符号将返回true，否则返回false
countTokens() 得到一共有多少个语言符号

1、文本框
TextField() 构造文本框，一个字符长、TextField(int x) 构造文本框，x个字符长
TextField(String s) 构造文本框，显示s、setText(String s) 设置文本为s
getText() 获取文本、setEchoChar(char c) 设置显示字符为c
setEditable(boolean) 设置文本框是否可以被修改、addActionListener() 添加监视器
removeActionListener() 移去监视器
2、文本区
TextArea() 构造文本区；TextArea(String s) 构造文本区，显示s
TextArea(String s,int x,int y) 构造文本区，x行，y列，显示s
TextArea(int x,int y) 构造文本区，x行，y列
TextArea(String s,int x,ing y,int scrollbar)
scrollbar的值是：
TextArea.SCROLLBARS_BOTH；TextArea.SCROLLBARS_VERTICAL_ONLY
TextArea.SCROLLBARS_HORIZONTAL_ONLY；TextArea.SCROLLBARS_NONE
setText(String s) 设置文本为s；getText() 获取文本
addTextListener() 添加监视器；removeTextListener() 移去监视器
insert(String s,int x) 在x处插入文本s
replaceRange(String s,int x,int y) 用s替换从x到y处的文本
append(String s) 在文本的最后追加文本s
Int getCaretPosition(int n) 获取文本区中光标的位置

第三章 按钮

1、按钮
Button() 构造按钮；Button(String s) 构造按钮，标签是s
setLabel(String s) 设置按钮标签是s；getLabel() 获取按钮标签
addActionListener() 添加监视器；removeActionListener() 移去监视器

第四章 标签

1、标签
Label() 构造标签；Label(String s) 构造标签，显示s
Label(String s,int x)x是对齐方式，取值：Label.LEFT；Label.RIGHT；Label.CENTER
setText(String s) 设置文本s；getText() 获取文本
setBackground(Color c) 设置标签背景颜色；setForeground(Color c) 设置字体颜色

1、选择框
Checkbox() 构造选择框；Checkbox(String s) 构造选择框，给定标题s
Checkbox(String s,boolean b) b设定初始状态
Checkbox(String s,boolean b,CheckboxGroup g) g设定了所属的组（有了组就成为单选框）
addItemListener() 添加监视器；removeItemListener() 移去监视器
getState() 返回选择框的是否选中状态；setState(boolean b) 设置选择框的状态
getLabel() 获取选择框的标题；setLabel(String s) 设置选择框的标题为s

第六章 选择控件和滚动列表

1、选择控件
Choice() 构造选择控件；add(String s) 向选择控件增加一个选项
addItemListener() 添加监视器；removeItemListener() 移去监视器
getSelectedIndex() 返回当前选项的索引；getSelectedItem() 返回当前选项的字符串代表
insert(String s,int n) 在n处插入选项s
remove(int n)；removeAll()
2、滚动列表
List() 构造滚动列表；List(int n) 参数n是可见行数
List(int n,boolean b) 参数b是设置是否可以多项选择
add(String s) 向列表的结尾增加一个选项；add(String s,int n) 在n处增加一个选项
AddActionListener() 滚动列表添加监视器
addItemListener() 滚动列表上的选项添加监视器
remove(int n) 删除n初的选项；remnoveAll() 删除全部选项
getSelectedIndex() 返回当前选项的索引；getSelectedItem() 返回当前选项的字符串代表
3、组件类的一些常用方法
void setBackground(Color c) 设置组件背景颜色
void setForeground(Color c) 设置组件前景颜色
void setFonts(Font f) 设置组件字体
void setBounds(int x,int y,int w,int h) 设置坐标，x，y表示在容器中坐标，w,h表示宽和高
void setLocation(int x,int y) 移动到x，y 处；void setSize(int w,int h) 设置宽和高
void setVisible(boolean b) 设置组建是否可见
int getBounds().wigth 获取宽；int getBounds().height 获取高
int getBounds().x 获取x 坐标；int getBounds().y 获取y 坐标
Toolkit getToolkit() 获取工具包对
void setEnabled(boolean b) 设置是否可以使用（默认可以）

1、窗口
Frame() 构造窗口；Frame(String s) 窗口标题是s
setBounds(int x,int y,int w,int h) 窗口位置x，y，宽w,高y
setSize(int w,int h) 设置窗口位置（单位是像素）
setBackground(Color c) 设置背景颜色；setVisible(boolean b) 设置窗口是否可见
pack() 窗口出现时紧凑；setTitle(String s) 设置标题为s
getTitle() 获取标题；setResizable(boolean b) 设置窗口大小是否可以调整
2、菜单条
Menubar() 构造菜单条；setMenubar() 窗口添加菜单条
3、菜单
Menu() 构造菜单；Menu(String s) 构造菜单，标题s
add(MenuItem item) 菜单增加菜单选项item；add(String s) 向菜单增加选项s
getItem(int n) 获取n处的选项；getItemCount() 获取选项数目
insert(MenuItem item,int n) 在n处插入菜单选项item
insert(String s,int n) 在n处插入菜单选项
remove(int n) 删除菜单的n处的菜单选项；removeAll() 删除全部
4、菜单项
MenuItem() 构造菜单项；MenuItem(String s) 构造标题是s的菜单项
setEnabled(boolean b) 设置是否可以被选择；getLabel() 得到菜单选项名
addActionListener() 添加监视器
5、有关菜单的技巧
addSeparator() 增加菜单分割线；CheckboxMenuItem() 复选框菜单项
setShortcut(MenuShortcut k) 设置快捷键(k取值KeyEvent.VK_A----KeyEvent.VK_Z)

1、Dialog类
Dialog(Frame f,String s) 构造对话框，初始不可见，s是标题，f是对话框所依赖的窗口
Dialog(Frame f,String s,boolean b) b设置初始是否可见
getTitle() 获取对话框标题；setTitle(String s) 设置对话框标题
setModal(boolean b) 设置对话框模式；setSize(int w,int h) 设置对话框大小
setVisible(boolean b) 显示或隐藏对话框
2、FileDialog类
Filedialog(Frame f,String s,int mode) mode的值是fileDialog.LOAD或者fileDialog.SAVE
public String getDirectory() 获取当前文件对话框中显示的文件所属目录
public String getFile() 获取当前文件对话框中文件的字符串表示，不存在返回null

1、使用MouseListener借口处理鼠标事件
鼠标事件有5种：按下鼠标键，释放鼠标键，点击鼠标键，鼠标进入和鼠标退出
鼠标事件类型是MouseEvent，主要方法有：
getX(),getY() 获取鼠标位置；getModifiers() 获取鼠标左键或者右键
getClickCount() 获取鼠标被点击的次数；getSource() 获取鼠标发生的事件源
事件源获得监视器的方法addMouseListener()，移去监视器的方法removeMouseListener()
处理事件源发生的时间的事件的接口是MouseListener 接口中有如下的方法
mousePressed(MouseEvent) 负责处理鼠标按下事件
mouseReleased(MouseEvent) 负责处理鼠标释放事件
mouseEntered(MouseEvent) 负责处理鼠标进入容器事件
mouseExited(MouseEvent) 负责处理鼠标离开事件
mouseClicked(MouseEvent) 负责处理点击事件
2、使用MouseMotionListener接口处理鼠标事件
事件源发生的鼠标事件有2种：拖动鼠标和鼠标移动；鼠标事件的类型是MouseEvent
事件源获得监视器的方法是addMouseMotionListener()
处理事件源发生的事件的接口是MouseMotionListener 接口中有如下的方法
mouseDragged() 负责处理鼠标拖动事件；mouseMoved() 负责处理鼠标移动事件
3、控制鼠标的指针形状
setCursor(Cursor.getPreddfinedCursor(Cursor.鼠标形状定义)) 鼠标形状定义见（书 P 210）
4、键盘事件
键盘事件源使用addKeyListener 方法获得监视器
键盘事件的接口是KeyListener 接口中有3个方法
public void keyPressed(KeyEvent e) 按下键盘按键
public void keyReleased(KeyEvent e) 释放键盘按键
public void keyTypde(KeyEvent e) 按下又释放键盘按键

1、Java的线程类与Runnable接口
Thread类
public Thread() 创建线程对象；  public Thread(Runnable target)
target称为被创建线程的目标对象，负责实现Runnable
线程优先级
Thread类有三个有关线程优先级的静态常量：MIN_PRIORITY,MAX_PRIORITY,NORM_PRIORITY
新建线程将继承创建它的副线程的优先级。
用户可以调用Thread类的setPriority(int a)来修改a的取值:
Thread.MIN_PRIORITY,Thread.MAX_PRIORITY,Thread.NORM_PRIORITY
主要方法
启动线程 start()；定义线程操作 run()
使线程休眠 sleep()：sleep(int millsecond) 以毫秒为单位的休眠时间
sleep(int millsecond,int nanosecond) 以纳秒为单位的休眠时间
currentThread() 判断谁在占用CPU的线程

1、FileInputStream类
FileInputStream(String name) 使用给定的文件名name创建一个FileInputStream对象
FileInputStream(File file) 使用File对象创建FileInpuStream对象
File类有两个常用方法：
File(String s) s确定文件名字；File(String directory,String s) directory是文件目录
处理I/O异常
当出现I/O错误的时候，Java生成一个IOException(I/O异常)对象来表示这个错误的信号。
程序必须使用一个catch检测这个异常

从输入流中读取字节
int read() 返回0~255之间一个整数，如果到输入流末尾，则返回-1
int read(byte b[]) 读取字节数组
int read(byte b[],int off,int len)：
off指定把数据存放在b中什么地方，len指定读取的最大字节数
关闭流
close()
2、FileOutputStream类
FileOutputStream(String name) 使用指定的文件名name创建FileOutputStream对象
FileOutputStream（File file） 使用file对象创建FileOutputStream对象
FileOutputStream（FileDescriptor fdobj） 使用FileDescriptor对象创建FileOutputStream对象
3、FileReader类和FileWriter类
FileReader(String filename)；FileWriter(String filename)
处理时需要FileNotFoundException异常
4、RandomAccessFile类
RandomAccessFile不同于FileInputStream和FileOutputStream,不是他们的子类
当我们想对一个文件进行读写操作的时候，创建一个指向该文件的RandomAccessFile流就行了
RandomAccessFile类有两个构造方法：
RandomAccessFile（String name, String mode） name是文件名，mode取r(只读)或rw(读写)
RandomAccessFile（File file,String mode） file给出创建流的源
seek(long a) 移动RandomAccessFile流指向文件的指针,a确定指针距文件开头的位置
getFilePointer() 获取当前文件的指针位置；close() 关闭文件
getFD() 获取文件的FileDescriptor；length() 获取文件长度
read() 读取一个字节数据；readBoolean() 读取一个布尔值；readByte() 读取一个字节
readChar()；readFloat()；readFully(byte b[])；readInt()；readLine()；readLong()
readUnsignedShort()；readUTF() 读取一个UTF字符串
setLength(long newLength) 设置文件长度；skipByte(int n) 在文件中跳过给定数量的字节
write(byte b[]) 写b.length个字节到文件；writeBoolean(bolean b)
writeByte(int v)；writeChar(char c)；writeChars(String s)；writeDouble(double d)
writeFloat(float v)；writeInt(int i)；writeLong(long l)；writeShort(int i)
writeUTF(String s)
5、管道流
PipedInputStream类；PipedInputStream() 创建一个管道输入流
PipedInputStream（PipedOutputStream a） 连接到输出流a的输入流
read() 从输入流中读取一个字节
read(byte b[],int off,int len) off是在b中的开始位置，len是字节长度
PipedOutputStream类；PipedOutputStream() 创建一个输出流
PipedOutputStream(PipedInputStream a) 连接到输入流a的输出流
write(int b)；write(byte b[],int off,int len)
counnect() 连接输入输出流；close() 关闭流；在使用的时候要捕获IOException异常。
6、数据流
DataInputStream类(数据输入流)
DataInputStream(InputStream in) 将数据输入流指向一个由in指定的输入流
DataOutputStream类(数据输出流)
DataOutputStream(OutputStream out) 将数据输出流指向一个由out指定的输出流
主要方法：
close()；read() 读取一个字节数据；readBoolean() 读取一个布尔值
readByte() 读取一个字节；readChar()；readFloat()；readFully(byte b[])
readInt()；readLine()；readLong()；readUnsignedShort()
readUTF() 读取一个UTF字符串；skipByte(int n) 在文件中跳过给定数量的字节
write(byte b[]) 写b.length个字节到文件；writeBoolean(bolean b)
writeByte(int v)；writeChar(char c)；writeChars(String s)；
writeDouble(double d)；writeFloat(float v)；writeInt(int i)
writeLong(long l)；writeShort(int i)；writeUTF(String s)
7、对象流
ObjectInputStream类和ObjectOutputStream类分别是DataInputStream类和DataOutputStream类的子类
8、回压输入流
PushbackInputStream类；PushbackInputStream(InputStream in)
PushbackReader类；PushbackReader(Reader in)
unread(char c) 回压一个字符；unread(char c[]) 回压数组c中全部字符
unread(char c[],offset,int n) 回压c中从offset开始的n个字符

1、使用URL（统一资源定位）
例如：
try
{
url=new URL("http://www.sina.com.cn";
}
catch(MalformedURLException e)
{
System.out.println("Bad URL:"+url);
}
在Applet 中链接向另外的Web页面，使用代码：
getAppletContext().showDocument(url);
2、套接字
客户建立到服务器的套接字（Socket）
Socket(String host,int port) host是服务器的IP地址，port是端口号
建立了套接字后可以使用getInputStream()获得输入流
还可以使用getOutputStream()获得一个输出流
服务器建立接受客户套接字的服务器套接字（ServerSocket）
ServerSocket(int port) port是端口号
建立了套接字连接后可以使用accept()接收客户的套接字
可以使用getOutputStream()获得一个输出流
还可以使用getInputStream()获得一个输入流
3、InetAddress类
getByName(String s) 获取Internet上主机的地址
getHostName() 获取InetAddress对象所包含的域名
getHostAddress() 获取InetAddress对象所包含的IP地址
getLocalHost() 获取本地地址
4、UDP数据报
发送数据包，即使用DatagramPacket类将数据打包,有两种构造方法
DatagramPacket(byte data[],int length,InetAddress address,int port)
?含有data数组的数据
?该数据包将发送到地质是address，端口是port的主机上
DatagramPacket(byte data[],int offset,int length,InetAddress address,int port)
?含有data数组的从offset开始，length长度的数据
?该数据包将发送到地质是address，端口是port的主机上
接收数据包，即使用DatagramSocket（int port）创建一个对象，port必须和待接收的数据包的端口相同
例如：
如果发送方的数据包端口是5566
DatagramSocket mail=new DatagramSocket(5566);
然后对象mail可以使用方法receive（Datagrampacket pack）接收数据包
在使用参数pack 接收数据包前，必须创建pack
byte data[]=new byte[100];
int length=90;
DatagramPacket pack=new DatagramPataet(data,length);
mail.receive(pack);
该数据包pack将接收长度是length的数据放入data,注意数据长度不要超过8192KB
pack还可以调用方法getPort()获取所接受数据包是从什么端口发出的
调用方法InetAddress getAddress()可以获知数据包来自哪个主机

1、java支持的图像类型：GIF，JPEG，BMP
2、Image类
首先申请一个Image对象
Image img =getImage(URL url,String name) url是图像地址，name是图片名称
通常使用：
Image img =getImage(getCodBase(),String name) getCodBase()获取当前小应用程序的URL，也就是在同一目录下
图像被加载后，就可以在paint()中绘制了
drawImage(Image img,int x,int y,ImageObserver observer)
img是上面获取的图像， x,y是指定图像左上角的位置，observer是加载图像时的图像观察器
Applet类已经实现了ImageObserver接口，所以可以直接使用this作为最后一个参数
drawImage(Image img,int x,int y,int width,int height,ImageObserver observer)
width和height是要绘制的图像的宽和高
可以使用img.getHeight(this)和img.getWidth(this)来获取被加载的图像的宽和高
3、设置Java窗口图标
Frame对象可以使用setIconImage(Image img)方法设置左上角图标，默认图标是咖啡杯

1、JDBC-ODBC桥接器
建立JDBC-ODBC桥接器
try
{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver";
}
catch(ClassNotFoundException e){}
连接到数据库
try
{
Connection con=DriverManager.getConnection("jdbc:jdbc:数据源名称","数据源的login name"，
"数据源的password"
}
catch(SQLException e){}
向数据库发送SQL语句
try
{
Statement sql=con.createStatement();
}
catch(SQLException e){}
处理查询结果
ResultSet rs=sql.executeQuery("SQL语句";

1、在小程序中播放声音
java可以播放au,aiff,wav,midi,rfm格式的音频
可以调用Applet的一个静态方法：
newAudioClip(URL url,String name) url是地址，name是音频名称
也可以用Applet类的实例方法：
getAudioClip(URL url,String name)
根据url地址和声音文件name，获得一个用于播放的音频对象，这对象可以使用下面的方法来处理声音：
play() 播放声音文件name；loop() 循环播放name；stop() 停止播放name
2、Java媒体框架(JMF)
创建播放器
try
{
URL url=new URL(getDocumenBase(),视频文件名称);
player player=Manager.createPlayer(url);
}
catch(IOException e){}
向播放器注册控制监视器
player.addControllerListener(监视器);
创建监视器必须使用接口ControllerListener ，该接口中的方法是
public void controllerUpdate(ControllerEvent e)
让播放器对媒体进行预提取：player.prefetch()
启动播放器：player.start();
停止播放器：player.stop();
停止播放器后必须释放内存中的资源：player.deallocate();

1、Jcomponent类
Jcomponent类 是所有轻量组件的父类，主要的子类有：
JButton 创建按钮对象，而且可以创建在图标的按钮； JTree 创建树对象
JComboBox 创建组合框对象，和Choice相似；JCheckBox 创建复选框对象
JFileChooser 创建文件选择器；JInternalFrame 创建内部窗体
JLabel 创建标签；JMenu 创建菜单对象；JMenuBar 创建菜单条对象
JMenuItem 创建菜单项对象；JPanel 创建面板对象；JPasswordField 创建口令文本对象
JPopupMenu 创建弹出式菜单；JProgressBar 创建进程条；JRadioButton 创建单选按钮
JScrollBar 创建滚动条；JScrollPane 创建滚动窗格；JSlider 创建滚动条
JSplitPane 创建拆分窗格；JTable 创建表格；JTextArea 创建文本区
JTexPane 创建文本窗格；JToolBar 创建工具条；JToolTip 创建工具提示对象
2、JFrame类
JFrame类及其子类创建的对象是窗体
（1）JFrame类及其子类创建的窗体是swing窗体
（2）不可以把组件直接加到swing窗体中，应该把组件加到内容面板中
（3）不能为swing窗体设置布局，而应当为内容面板设置布局
（4）swing窗体通过调用getContentPane()方法得到它的内容面板
3、JApplet类
（1）不可以把组件直接添加到小程序容器中，也应该添加到内容面板中
（2）不能为小程序设置布局
（3）小程序容器通过调用getContenPane()方法得到内容面板
4、JDialog类
（1）不可以把组件直接添加到对话框容器中，也应该添加到内容面板中
（2）不能为对话框设置布局
（3）对话框容器通过调用getContenPane()方法得到内容面板
5、JPanel面板：JPanel()；JPanel(布局对象)
6、滚动窗口JScrollPane：JScrollPane()；JScrollPane(component c)
7、拆分窗口JSplitPane
JSplitPane(int a,Component b,Component c)
a的取值是HORIZONTAL_SPLIT或者VERTICAL_SPLIT决定水平拆分还是垂直拆分
JSplitPane(int a,boolean b ,Component b,Component c) b的取值决定拆分线移动的时候组件是否连续变化
8、内部窗体JInternalFrame
JInternalFrame(String title,boolean resizable,booleam closable,boolean max,boolean min)
参数的意义分别是窗口名称，是否能调整大小，是否有关闭按钮，最大化按钮，最小化按钮
（1）不能把组件直接加到窗体中，而是加到内容面板中
（2）必须先把内部窗体加到一个容器中（JDesktopPane），该容器是专门为内部窗体服务的
9、按钮（JButton）
JButton() 创建按钮；JButton(String s) s是按钮的名字
JButton(Icon icon) icon是按钮上的图标；JButton(String s,Icon icon)
getText() 获取按钮名字；getIcon() 获取按钮图标
setIcon(Icon icon) 设置按钮图标
setHorizontalTextposition(int a) a确定按钮上图标的位置，取值：
AbstractButton_CENTR,AbstractButton_LEFT,AbstractButton_RIGHT
setVerticalTextposition(int a) a确定按钮上名字相对图标的位置，取值：
AbstractButton.TOP，AbstractButton.BOTTOM，AbstractButton.CENTR
setMnemonic(char c) 设置按钮的键盘操作方式是字符c（Alt+c）
setEnabled(boolean b) b决定按钮是否可以被单击

## 使用SimpleLog实现
#org.apache.commons.logging.Log=org.apache.commons.logging.impl.SimpleLog

后面的值是你想要的实现日志接口的类.apache的commons-logging.jar本身带了两个实现,SimpleLog
是其中的一个,如果 你的要使用Log4J,还必须把Log4J大相关jar放到相应的lib下.


2.如果使用SimpleLog,那么在WEB-INF\classes下要有一个simplelog.properties文件,内容:
//---------------------------------------------
org.apache.commons.logging.simplelog.defaultlog = info

主要是定义SimpleLog日志输出级别.


3.使用Log4J进行日志输出不仅可以定义输出的级别,还可以定义输出的地方和输出的格式.而simplelog只有System.err.         Log4J主要是定义三个Logger,appender 和layout,appender 是输出的地方,layout就是布局,也就是输出的格式.
//-----------------------------------------------

## LOGGERS ##
#定义一个logger
log4j.rootLogger=INFO,console,file

## APPENDERS ##
#定义一个appender,后面的红色字体就是他的名字,可以任意定义.其值是相关的输出的类.可取值如
#ConsoleAppender
#RollingFileAppender
#DailyRollingFileAppender
..............................................

# log4j.appender.console=org.apache.log4j.ConsoleAppender

log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.File=log.txt

#如果使用FileAppender那么后面还跟很有多属性如MaxFileSize,MaxBackupIndex等.

## LAYOUTS ##

# 定义格式
#格式主要有好几中常用的就是SimpleLayout,HTMLLayout,PatternLayout,使用PatternLayout时后面还要有一个定义格式的ConversionPattern.
log4j.appender.console.layout=org.apache.log4j.SimpleLayout

# PatternLayout
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%t %p - %m%n

#以下是使用的方法:
1.在action,servlet中

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

         Log log=LogFactory.getLog("helloapplog");
         log.trace("This is a trace message");
         log.debug("This is a debug message");
         log.info("This is an info message");
         log.warn("This is a warn message");
         log.error("This is an error message");
         log.fatal("This is a fatal message");

2.在jsp中.

 <%@ page import="org.apache.commons.logging.Log" %>
<%@ page import="org.apache.commons.logging.LogFactory" %>
<% Log logger = LogFactory.getLog( this.getClass(  ) ); %>
  <% logger.warn( "This is a warn message from a jsp" ); %>
  <% logger.error( "This is an error message from a jsp" ); %>

(一)Query
 1.TermQuey//查询特定的某个Field
 //过程:
 Term t = new Term("subject", "ant");
 //Term构造函数的参数:param1是Field名,param2是用户查询的关键字
 Query query = new TermQuery(t);
 Hits hits = searcher.Search(query);
 2.QueryParse//简化查询语句
 //过程:
 Query query = QueryParser.Parse("+JUNIT +ANT -MOCK","contents",new SimpleAnalyzer());
 Hits hits = searcher.Search(query);
 //注意:TermQuery和QueryParse只要在QueryParse的Parse方法中只有一个word,就会自动转换成TermQuery.
 3.RangeQuery//范围查询,用于查询范围,通常用于时间
 //过程:
 RangeQuery query = new RangeQuery(begin, end, true);
 Hits hits = searcher.Search(query);
 //RangeQuery的第三个参数用于表示是否包含该起止日期.Lucene用[] 和{}分别表示包含和不包含.RangeQuery到QueryParse的转化
 //Query query = QueryParser.Parse("pubmonth:[200004 TO 200206]", "subject", new SimpleAnalyzer());
 //IndexSearcher searcher = new IndexSearcher(directory);
 //Hits hits = searcher.Search(query);
 4.PrefixQuery//搜索是否包含某个特定前缀
 PrefixQuery query = new PrefixQuery(new Term("category", "/Computers"));
 Hits hits = searcher.Search(query);
 5.BooleanQuery//用于测试满足多个条件
 TermQuery searchingBooks =new TermQuery(new Term("subject", "junit"));
 RangeQuery currentBooks =new RangeQuery(new Term("pubmonth", "200301"),new Term("pubmonth", "200312"),true);
 BooleanQuery currentSearchingBooks = new BooleanQuery();
 currentSearchingBooks.Add(searchingBooks, true, false);
 currentSearchingBooks.Add(currentBooks, true, false);
 IndexSearcher searcher = new IndexSearcher(directory);
 Hits hits = searcher.Search(currentSearchingBooks);
 //什么时候是与什么时候又是或? 关键在于BooleanQuery对象的Add方法的参数.
 //参数一是待添加的查询条件.
 //参数二Required表示这个条件必须满足吗? True表示必须满足, False表示可以不满足该条件.
 //参数三Prohibited表示这个条件必须拒绝吗? True表示这么满足这个条件的结果要排除, False表示可以满足该条件.
 //BooleanQuery和QueryParse
 [Test]
         public void TestQueryParser()
         {
              Query query = QueryParser.Parse("pubmonth:[200301 TO 200312] AND junit", "subject", new SimpleAnalyzer());
              IndexSearcher searcher = new IndexSearcher(directory);
              Hits hits = searcher.Search(query);
              Assert.AreEqual(1, hits.Length());
              query = QueryParser.Parse("/Computers/JUnit OR /Computers/Ant", "category", new WhitespaceAnalyzer());
              hits = searcher.Search(query);
              Assert.AreEqual(2, hits.Length());
         }

  //注意AND和OR的大小 如果想要Ａ与非B 就用 A AND –B 表示, +A –B也可以.

  //默认的情况下QueryParser会把空格认为是或关系,就象google一样.但是你可以通过QueryParser对象修改这一属性.

[Test]
         public void TestQueryParserDefaultAND()
         {
              QueryParser qp = new QueryParser("subject", new SimpleAnalyzer());
              qp.SetOperator(QueryParser.DEFAULT_OPERATOR_AND );
              Query query = qp.Parse("pubmonth:[200301 TO 200312] junit");
              IndexSearcher searcher = new IndexSearcher(directory);
              Hits hits = searcher.Search(query);
              Assert.AreEqual(1, hits.Length());

         }

 6.PhraseQuery//短语查询
 7.WildcardQuery//通配符搜索
 8.FuzzyQuery//模糊查询

(二)Analyzer

 WhitespaceAnalyzer:仅仅是去除空格，对字符没有lowcase化,不支持中文
 SimpleAnalyzer:功能强于WhitespaceAnalyzer,将除去letter之外的符号全部过滤掉,并且将所有的字符lowcase化,
 不支持中文
 StopAnalyzer:StopAnalyzer的功能超越了SimpleAnalyzer，在SimpleAnalyzer的基础上
    增加了去除StopWords的功能,不支持中文
 StandardAnalyzer:英文的处理能力同于StopAnalyzer.支持中文采用的方法为单字切分.
 ChineseAnalyzer:来自于Lucene的sand box.性能类似于StandardAnalyzer,缺点是不支持中英文混和分词.
 CJKAnalyzer:chedong写的CJKAnalyzer的功能在英文处理上的功能和StandardAnalyzer相同
    但是在汉语的分词上，不能过滤掉标点符号，即使用二元切分
 最强大的分析程序——StandardAnalyzer类。
 StandardAnalyzer类会将文本的所有内容变成小写的，并去掉一些常用的停顿词（stop word）。
 停顿词是像“a”、“the”和“in”这样的词，它们都是内容里非常常见的词，但是对搜索却一点用处都没有。
 分析程序也会分析搜索查询，这就意味着查询会找到匹配的部分。例如，
 这段文本“The dog is a golden retriever（这条狗是一只金毛猎犬）”，
 就会被处理为“dog golden retriever”作为索引。当用户搜索“a Golden Dog”的时候，
 分析程序会处理这个查询，并将其转变为“golden dog”，这就符合我们的内容了。

(三)性能问题
 1.切词,索引,存属
 域存储字段规则
 方法 切词 索引 存储 用途
 Field.Text(String name, String value) 切分词索引并存储，比如：标题，内容字段
 Field.Text(String name, Reader value)  切分词索引不存储，比如：META信息，
 不用于返回显示，但需要进行检索内容
 Field.Keyword(String name, String value)  不切分索引并存储，比如：日期字段
 Field.UnIndexed(String name, String value)  不索引，只存储，比如：文件路径
 Field.UnStored(String name, String value)  只全文索引，不存储
-----------------------------------------------------------------------------------------------
 Keywork
 该类型的数据将不被分析,而会被索引并保存保存在索引中.
 UnIndexed
 该类型的数据不会被分析也不会被索引,但是会保存在索引.
 UnStored
 和UnIndexed刚好相反,被分析被索引,但是不被保存.
 Text
 和UnStrored类似.如果值的类型为string还会被保存.如果值的类型Reader就不会被保存和UnStored一样.
 
 2.优化索引生成文件
  1.索引的权重SetBoost
   if (GetSenderDomain().EndsWith(COMPANY_DOMAIN))
   //如果是公司邮件,提高权重,默认权重是1.0
           doc.SetBoost(1.5);                      
   else
   //如果是私人邮件,降低权重.
           doc.SetBoost(0.1);
  不仅如此你还可以对Field也设置权重.比如你对邮件的主题更感兴趣.就可以提高它的权重. 
  Field senderNameField = Field.Text("senderName", senderName);
  Field subjectField = Field.Text("subject", subject);
  subjectField.SetBoost(1.2);

  2.利用IndexWriter 属性对建立索引进行高级管理
   在建立索引的时候对性能影响最大的地方就是在将索引写入文件的时候所以在具体应用的时候就需要对此加以控制
   IndexWriter属性  
   描述   默认值   备注
   MergeFactory 10    控制segment合并的频率和大小
   MaxMergeDocs Int32.MaxValue 限制每个segment中包含的文档数
   MinMergeDocs 10    当内存中的文档达到多少的时候再写入segment

   Lucene默认情况是每加入10份文档就从内存往index文件写入并生成一个segement,然后每10个segment就合并成一个segment.通过MergeFactory这个变量就可以对此进行控制.
   MaxMergeDocs用于控制一个segment文件中最多包含的Document数.比如限制为100的话,即使当前有10个segment也不会合并,因为合并后的segmnet将包含1000个文档,超过了限制.
   MinMergeDocs用于确定一个当内存中文档达到多少的时候才写入文件,该项对segment的数量和大小不会有什么影响,它仅仅影响内存的使用,进一步影响写索引的效率.

  3.利用RAMDirectory充分发挥内存的优势
   在实际应用中RAMDirectory和FSDirectory协作可以更好的利用内存来优化建立索引的时间.
   具体方法如下:
   1.建立一个使用FSDirectory的IndexWriter
   2.建立一个使用RAMDirectory的IndexWriter
   3. 把Document添加到RAMDirectory中
   4. 当达到某种条件将RAMDirectory 中的Document写入FSDirectory.
   5. 重复第三步

   示意代码:
      private FSDirectory fsDir = FSDirectory.GetDirectory("index",true); 

       private RAMDirectory ramDir = new RAMDirectory();

       private IndexWriter fsWriter = IndexWriter(fsDir,new SimpleAnalyzer(), true);
       private IndexWriter ramWriter = new IndexWriter(ramDir,new SimpleAnalyzer(), true);
       while (there are documents to index)
      {
         ramWriter.addDocument(doc);
         if (condition for flushing memory to disk has been met)
         {
           fsWriter.AddIndexes(Directory[]{ramDir}) ;
           ramWriter.Close();          //why not support flush?
           ramWriter =new IndexWriter(ramDir,new SimpleAnalyzer(),true);
         }
     }
   这里的条件完全由用户控制,而不是FSDirectory采用对Document计数的方式控制何时写入文件.
   相比之下有更大的自由性,更能提升性能.
  4.控制索引内容的长度
   Lucene对一份文本建立索引时默认的索引长度是10,000. 你可以通过IndexWriter 的MaxFieldLength属性对此加以修改.还是用一个例子说明问题.
  5.Optimize 优化

=------------------------jackstudio-----------------