(原)Java 专业人士必备的书籍和网站列表 您必备的参考资料

文档选项     未显示需要 JavaScript 的文档选项 拓展 Tomcat 应用 下载 IBM 开源 J2EE 应用服务器 WAS CE 新版本 V1.1

级别: 初级

Roy Miller (roy@roywmiller.com), 创始人兼总裁, The Other Road, LLC

2007 年 1 月 15 日

对于 Java™ 语言开发人员来说，信息过量是一个真正的问题。每个新入行的程序员都要面临一个令人畏缩的挑战：要进入的行业是一个具有海量知识的行业。要了解的东西简直太多了。对于有经验的老手来说，情况只有些微好转。知识量总在增大，仅仅跟上进度就是一个挑战。如果有一份专业人士必备的书籍和网站列表该有多好！本文就是这个列表。它包含了每个专业的 Java 语言程序员在书架或浏览器书签中必备的最重要的书籍和网站。

这些都是您书架上必备的书和应该经常使用的 Web 链接。时间是一项重要的资源，本文帮您回避那些分心的事情，把时间专注于最有益于您作为Java 语言程序员职业生涯的信息源。尽管有多少程序员就有多少他们最喜欢的参考资料，但本文收集的这些都是优中选优，来源于我书架上的私家珍藏和许多 Java 专家的推荐。

我考虑了两种组织这份参考资料列表的方法。我本可以通过主题领域来组织，这也许很有帮助，但主题列表很快就会变得不实用。相反，我选择了另一种方法：通过类型来组织，即书籍和 Web 站点。

总的来讲，有经验的老手们用 Web 站点来跟踪行业的走势。书籍、文章和论文有助于跟上潮流，但它们总体上更适合于基础学习。极富创造性的书籍偶尔会撼动一两个基础性的东西。这样的书也在本列表之列。

需要提出的一点警告是，专注于 Java 语言的书籍和 Web 站点数量巨大。您钟爱的未必在这份列表里。那并不意味着它们不好。它们只是不在这份列表里而已。可能是因为我还不知道它们。也可能是因为我不认为它们能够算得上是重要资源。不包含一些参考资料是一个评判问题，但如果不这样的话，您也许就要花几小时来拖动滚动条，还要花上成千上万美元来买书。如果您作为一个专业的 Java 程序员，有一些常用的优秀参考资料，一定要让我知道这些资料。这份列表一直都在更新中，您提出的那些也许就会被收录进去。

书籍

每个程序员都会有一些由于经常被当作专业资料参阅而磨坏的书。下列书籍应该是 Java 语言程序员的书架上必备的。书很贵，所以我有意将这份列表弄得很短，仅限于重要书籍。

Thinking in Java (Bruce Eckel)

Thinking in Java, 3rd edition （Bruce Eckel; Prentice Hall PTR，2002 年）
Java 编程思想：第3版 （陈昊鹏 等译; 机械工业出版社，2005 年）
Eckel 的书对于学习如何在 Java 语言环境中使用好面向对象技术极其实用。书中大量的代码样例解释了他所介绍的概念。文字出自一个并不认为 Java 技术总是正确答案的人，所以相当地实用。Eckel 具有多种语言的大量经验，还有用面向对象方式进行思考的扎实技能。本书将这些技能放到实用的 Java 语言环境中。他还在写一本新书，名为 Thinking in Enterprise Java。

Effective Java (Joshua Bloch)

Effective Java: Programming Language Guide （Joshua Bloch; Addison-Wesley，2001 年）
Effective Java 中文版 （潘爱民 译; 机械工业出版社，2003 年）
本书是理解优秀 Java 程序设计原则的最佳书籍。大多数材料从其他的 “学习 Java ” 的书中根本找不到。例如，Bloch 书中关于覆盖 equals() 这一章是我读过的最好的参考资料之一。他也在书中包括了很实用的建议：用接口替代抽象类和灵活使用异常。Bloch 是 Sun 公司 Java 平台库的架构师，所以他透彻地了解这门语言。事实上，他编写了该语言中大量有用的库。本书必读！

The Java Programming Language (Ken Arnold, James Gosling, David Holmes)

The Java Programming Language （Ken Arnold，James Gosling，David Holmes; Addison-Wesley，2000 年）
Java 编程语言（第 3 版） （虞万荣 等译，中国电力出版社，2003 年）
这也许是能弄到的最好的 Java 入门读物。它并不是一个标准规范，而是一本介绍每门语言特性的可读书籍。这本书在严谨性和教育性方面权衡得很好，能够让懂编程的人迅速被 Java 语言（和其丰富的类库）所吸引。

Concurrent Programming in Java: Design Principles and Patterns (Doug Lea)

Concurrent Programming in Java: Design Principles and Patterns, 2nd edition （Doug Lea; Addison-Wesley，1999 年）
Java 并发编程—设计原则与模式（第二版） （赵涌 等译，中国电力出版社，2004 年）
不是每个开发人员都需要如此细致地了解并发性，也不是每个工程师都能达到本书的水准，但却没有比本书更好的关于并发性编程的概述了。如果您对此感兴趣，请从这里开始。Lea 是 SUNY 的一名专业程序员，他的和并发性有关的作品和想法都包含在了 JDK 5.0 规范（引自 JSR166）中，所以您大可放心，他所说的关于有效使用 Java 语言的建议是值得一听的。他是一个很善于沟通的人。

Expert One-On-One J2EE Design and Development (Rod Johnson)

Expert One-On-One J2EE Design and Development （Rod Johnson）
WROX: J2EE 设计开发编程指南 （魏海萍 译，电子工业出版社，2003 年）
对于刚接触 J2EE 的人来说，这是唯一的一本如实反映这项技术的书。本书收录了多年的成功经验和失败经验，不同于其他许多作者，Johnson 乐于将失败的经验公诸于众。J2EE 常常都被过度使用。Johnson 的书能帮您避免这一点。

Refactoring (Martin Fowler, Kent Beck, John Brant, William Opdyke, Don Roberts)

Refactoring: Improving the Design of Existing Code （Martin Fowler，Kent Beck，John Brant，William Opdyke，Don Roberts; Addison-Wesley，1999 年）
重构：改善既有代码的设计（中文版） （侯捷 等译，中国电力出版社 ，2003 年）
Fowler 写了几本现已出版的最流行的编程书，包括 Analysis Patterns。他的关于重构 的书是这一主题的基本书籍。重构代码是被程序员忽略的训练，但却是程序员最直观的想法。重构是在不改变代码结果的前提下改进现有代码的设计。这是保持代码整洁的最佳方式，用这种方法设计的代码总是很容易修改。什么时候进行重构呢？当代码“散发出味道”时。Fowler 的书里满是 Java 语言代码的例子。许多 Java 语言集成开发环境（IDE）（包括了 IBM 的 Eclipse）都将 Fowler 的重构包含了进去，每一个都使用他的重构名命名，所以熟悉如extract method 等重构方法还是很值得的。

Design Patterns (Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides)

Design Patterns: Elements of Reusable Object Oriented Software （Erich Gamma，Richard Helm，Ralph Johnson，John Vlissides; Addison-Wesley，1997 年）
设计模式：可复用面向对象软件的基础 （李英军 等译，机械工业出版社 ，2005 年）
这是一本在专业程序员圈子里更为有名的书，基于作者共同的绰号，这本书被认为是 “四人帮（GOF）之书”。模式是思考和解决普通编程问题时可以重用的方式。学习模式是一门学科。使用好模式（或知道什么时候不 使用模式）是一项技能。忽略模式则是错误的。书中所有的例子都以 C++ 表示，但 Java 语言是从那里诞生的，让 Java 语言程序员由此联系到如何在 Java 语言中实现这些模式相对简单一些。熟悉模式并了解如何使用好模式使编程更加简单。这使得和其他程序员交流也更简单，因为在针对通用问题的通用解决方案中，模式是描述解决方案中彼此协作的大量相关编程概念的快捷方式。一些更为通用的方式，如工厂方法 则是普便存在的，甚至存在于 Java 语言本身。关于明智使用模式的这个主题，也可以阅读 Joshua Kerievsky 的 Refactoring to Patterns，该书称可以让代码来告诉您何时实现模式。

Patterns of Enterprise Application Architecture (Martin Fowler)

Patterns of Enterprise Application Architecture （Martin Fowler; Addison-Wesley，2002 年）
企业应用架构模式 （王怀民 等译，机械工业出版社 ，2004 年）
比起小型、一次性项目来说，企业开发当然代表了更大的挑战。那并不意味着企业开发带来的所有挑战都是新挑战。事实上有些时候，这项开发已经 是以前完成过的了。Fowler 做了很多个这样的项目。他的书提到了一些通用解决方案，并提供了关于使用、折中和可选方案的指导。Fowler 在书中包含了一些熟悉的模式，如模型视图控制器（MVC），他也提供了一些您也许不了解的模式，如处理 Web 站点上特定页面请求或行为请求的 Page Controller 模式。正如您对待大多数模式一样，一旦您读过许多模式，您就会认为 “我已经知道那个模式了” 。也许是这样，但有一个用来引用模式的通用表达方式还是很有帮助的。在有多个组件（由不同人开发）的大型项目中，该类引用是一项很好的帮助。

UML Distilled (Martin Fowler)

UML Distilled: A Brief Guide to the Standard Object Modeling Language （Martin Fowler; Addison-Wesley 2003 年）
UML精粹：标准对象语言简明指南（第3版） （徐家福 译，清华大学出版社 ，2005 年）
对于专业的程序员来说，UML 是一门很重要的通用可视化沟通语言，但是它被过度使用和草率地滥用了。您无需对使用 UML 沟通了解太多。Martin 对 UML 的提炼为您提供了最核心的东西。事实上，前后的封页提供了常规基础上可能使用到的所有东西。该书中 UML 例子的代码都是 Java 代码。

Test-Driven Development: By Example (Kent Beck)

Test-Driven Development: By Example （Kent Beck; Addison-Wesley 2002 年）
测试驱动开发（中文版） （崔凯 译，中国电力出版社 ，2004 年）
测试优先编程将使编程发生革命性变化，能助您成为更好的程序员。在写代码之前编写测试开始很难，但却是一项威力强大的技能。通过优先编写测试，可使代码更加简单，并确保从一开始它就能工作（Beck 实践着他提倡的测试优先，与人合写了 JUnit，这是 Java 语言最流行的测试框架）。Beck 的书是权威的参考资料，扩展了的 Money 例子也用 Java 语言写成。Beck 详述了如何用测试优先进行 思考（这也许是许多程序员首先遇到的障碍）。

The Pragmatic Programmer: From Journeyman to Master (Andy Hunt and Dave Thomas)

The Pragmatic Programmer: From Journeyman to Master （Andrew Hunt 和 David Thomas; Addison-Wesley 1999 年）
程序员修炼之道——从小工到专家 （马维达 译，电子工业出版社 ，2004 年）
做一个纯粹的面向对象开发人员有其优势所在。在当今复杂的社会中，作为 Java 语言开发人员，为完成任务常要妥协。Hunt 和 Thomas 探讨了如何不将真正重要的东西妥协掉而完成任务。这不是一本关于 Java 语言的书，而是 Java 语言开发人员重要的思想读物。例如，我认为没从“要解决问题，而不是推卸责任”这句忠言中受益的程序员，不能像个自豪的艺术家一样在他的杰作上签上大名。

Peopleware: Productive Projects and Teams (Tom DeMarco and Timothy Lister)

Peopleware: Productive Projects and Teams （Tom DeMarco，Timothy Lister; Dorset House，1999 年）
人件（第2版） （UMLChina 翻译组 译，清华大学出版社 ，2003 年）
这份列表中的其他所有书籍都至少和技术有些相关。这本书却不是。在所有技术行话和首字母缩略词的海洋中，有时软件开发人员和经理们会忘记：是人 制造了软件。DeMarco 和 Lister 向我们提醒了这一事实，也向我们提醒了形成这一区别的原因。这不是一本关于一门特定编程语言的书籍，但却是每个 Java 语言程序员都应该读的书。关于 “累死程序员如何让经理们适得其反” 还有许多其他的好书，但这是最好的一本。

回页首

Web 站点

Web 站点的数目浩如烟海，如果您想要消化其中的内容，穷毕生之力也难以全部访问。包含 Java 语言某方面内容的详尽的网站列表会大得离谱。下列站点都是可靠、真实的。

Sun 的 Java 技术站点

Sun 的 Java 语言站点
这是 Sun 的 Java 语言主站。作为 Java 语言开发人员，您会发现自己频繁地访问此站点。下列链接特别重要，特别是对新入行的 Java 语言开发人员：

• New to Java Center
  New to Java Center
  New to Java Center 存放了许多循序渐进的 Java 技术资源链接。如果您刚接触这门语言，这是一个好的起点。
• 教程和代码库
  Java Tutorial
  这里有大名鼎鼎的 Java Tutorial，以及关于 Java 语言各个方面（例如 Collection）的其他教程。

IBM developerWorks

IBM 的 developerWorks
推销自己也许有些厚脸皮，但 developerWorks 是一项巨大的资源，收录了大量 Java 语言工具和技术的教程和文章。其内容从初学者指南到学习这门语言到高级并发性技术。可以根据主题搜索内容，然后根据类型浏览。

Apache Software Foundation

Apache Software Foundation
Apache 站点是许多可重用库（通用领域）和工具的主页，这些库和工具帮助 Java 开发人员进行开发。这里的内容全都是开放源码，所以尽管下载想要的吧！许多极其流行的 Java 语言库和工具（如 Struts、Ant 和 Tomcat）都始于 Apache 项目。Jakarta 专区汇聚了大多数新兴的 Java 语言材料。

Eclipse.org

Eclipse
有几个好的 Java 语言集成开发环境（IDE）。Eclipse（来自 IBM）是最新的 IDE 之一，它很快成为 Java 语言开发的首要 IDE。它完全是开源的，这意味着它是免费的。该站包含了学习如何有效使用 Eclipse 的各种参考资料。这里还有关于 Standard Widget Toolkit（SWT）的信息，SWT 是相对于 Swing 来说更加轻量级的选择。

Eclipse 插件中心和 Eclipse 插件

Eclipse 插件中心 和 Eclipse 插件
Eclipse 基于插件架构。事实上，插件是 Eclipse 的 Java 语言开发组件。但有差不多上千个插件，从 Web 开发的插件到在 Eclipse 环境中玩游戏的插件。这两个站点分类列出了大多数插件，可以进行搜索。它们是很棒的资源。如果您想在 Eclipse 开发环境中弄点新东西，幸运的话有某个插件可能已经实现，从这两个站点能找到想要的插件。这两个站点都允许评论插件，这样您就可以知道哪些插件好，哪些值得一试。

JUnit.org

JUnit.org
Junit 是 Java 语言中一个基本的单元测试框架。该站点包含了 Junit 最新最棒的版本，外加大量有关测试（Java 语言或者其他语言的）各个层面上（针对桌面应用程序、Web 应用程序、J2EE 应用程序等）的其他资源。如果您想找测试资源，这里就是最佳起点。

TheServerSide.com

TheServerSide.com
如果您要(或将要)从事服务器端 Java 语言的开发，此站点是一处举足轻重的资源。您可以到这里找到有关 JBoss、J2EE、LDAP、Struts 和大量其他主题的文章，并且都是完全可检索的。这些文章不仅仅是简单描述 Java 语言的特征或者支持的库。它们更进一步地描述了库的新奇用法（如使用 Jakarta Velocity 作为规则引擎，而不是模板引擎）。它们也提供了有关 Java 语言现状的连续评论（当前的一篇文章是由 Tim Bray 所写的 Java is boring ）。该站点更好的通用功能之一是对 Java 语言工具和产品（应用服务器等）的矩阵式比较。

Bruce Eckel's MindView, Inc.

Bruce Eckel's MindView, Inc.
Eckel 写了几本 “用 …… 进行思考” 的书，内容关于 Java 语言、Python 和 C++ ，当我学习 Java 语言时，他的 Thinking in Java 对我尤其有帮助。它很实用并切中要害，在“在 Java 语言环境中如何面向对象思考”方面具有卓识。您可以从此站点免费下载他所有书籍的电子版。他也写了许多好文章，并且他把这些文章的链接都放到了这里（包括关于 Jython、Java 和 .NET 比较等内容的文章）。

ONJava.com

ONJava.com
O'Reilley 历年来出版了一些有关编程语言和工具的优秀书籍。他们的专注于 Java 语言的网站也不错。它有些有关各种 Java 语言工具（如 JDOM 和 Hibernate）、Java 平台（如 J2SE 和 J2EE）不同领域不同部分的文章。全部都可以被检索到。他们有优秀的文章和教程。该站点按主题排列。例如有 Java 和 XML、Java Security、Wireless Java 和 Java SysAdmin。该站点也有到 O'Reilley Learning Lab 的链接，在那里您能获得在线参考资料（Java 语言相关和其他的）。那些不是免费的，但是许多都面向大学认证。因此您可以以一种很方便的方式来学习技能，并得到一些认证。

java.net

java.net 社区
java.net 社区有多个“社区”，有特定于主题的论坛和文章。例如 Java Desktop 社区有各类与 Java 语言桌面开发相关的资料。Java Patterns 社区作为一个门户，也许对提供 Java 语言的模式资源相当感兴趣。还有一个 Java User Groups (JUG) 社区，在那里能找到有关创建、加入和管理一个 JUG 的信息。

回页首

结束语

任何 “好的”、“关键性的” 或者 “重要的” 参考资料列表都注定是不完整的，本文的列表也未能例外。 Java 语言的书籍数目众多，当然，万维网也很庞大。除本文所列的参考资料之外，还有很多用于学习 Java 语言的参考资料。但如果您拥有了这里所提到的所有书籍、网站、文章或者教程，您应当已经拥有了一个使您良好开端并助您登堂入室的实用宝库。

最后，要成为一个能力日增和高效的 Java 语言开发人员，方法就是用它工作，动手来尝试。如果有一个教程详细介绍了所需创建的软件的每一部分，您很可能并没得到多少好处。有时，您可能得走自己的路。在成功地尝试了一些新的东西之后，您可能想要写一篇文章、教程或者一本书来分享您所学到的。

参考资料

• 您可以参阅本文在 developerWorks 全球站点上的 英文原文 。
  
  
• 在 developerWorks Java 技术专区 查找更多 Java 技术参考资料。
  
  
• 访问 Java 技术新手入门 站点，获取最新的参考资料，帮您开始使用 Java 编程。
  
  
• 通过参与 developerWorks blog 加入 developerWorks 社区。
  
  
• 浏览 关于这些主题和其他技术主题的书籍。
  

关于作者

		Roy Miller 是一名独立软件开发培训师、程序员兼作家，他在充满挑战、快节奏的咨询公司里从事了十多年软件开发和项目管理工作。他最初在 Andersen Consulting（现在是 Accenture）公司工作，在那里，他管理团队实现了许多系统，从主机记帐系统到星形模式数据集市。最近三年来，他在北卡罗来纳州 Holly Springs 的 RoleModel Software, Inc. 公司工作，在那里他专业地运用着 Java 技术，并担任开发人员兼 Extreme Programming (XP) 培训师。他与人合著了 Addison-Wesley XP 系列的 Extreme Programming Applied: Playing to Win 一书，最近他写了 Managing Software for Growth: Without Fear, Control and the Manufacturing Mindset 一书，来帮助经理和管理层理解：像 XP 这样的敏捷构建方法为什么比传统的方法更有效。2003 年，他创办了自己的公司：The Other Road，该公司帮助其他公司了解如何向 XP 和被他称为 Extreme Business (XB) 的方法转换。

如何在JSP页面中访问web.xml中的初始化参数?

<context-param>
 <param-name>productId</param-name>
如何从java代码中访问web.xml 中的初始化参数? 
你可以使用externalContext的 getInitParameter 方法得到他们.例如 如果你的参数如下: 
<context-param>
 <param-name>connectionString</param-name>
 <param-value>jdbc:oracle:thin:scott/tiger@cartman:1521:O901DB</param-value>
</context-param>
你可以使用下面代码访问connectionString : 
FacesContext fc = FacesContext.getCurrentInstance();
String connection = fc.getExternalContext().getInitParameter("connectionString");
 

如何实现"请等待..."页面?

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>
<f:loadBundle basename="demo.bundle.Messages" var="Message"/>
 
<html>
<head> 
  <title>Input Name Page</title>
  <script>
    function gowait() {
      document.getElementById("main").style.visibility="hidden";
      document.getElementById("wait").style.visibility="visible";
    }
   </script>
    
 </head>
 <body bgcolor="white">
  <f:view>
    <div id="main">
       <h1><h:outputText value="#{Message.inputname_header}"/></h1>
       <h:messages style="color: red"/>
       <h:form id="helloForm">
    
         <h:outputText value="#{Message.prompt}"/>
         <h:inputText id="userName" value="#{GetNameBean.userName}" required="true">
           <f:validateLength minimum="2" maximum="20"/>
         </h:inputText>
         <h:commandButton onclick="gowait()" id="submit" 
               action="#{GetNameBean.action}" value="Say Hello" />
       </h:form>
    </div>
    <div id="wait" style="visibility:hidden; position: absolute; top: 0; left: 0">
       <table width="100%" height ="300px"> 
         <tr>
           <td align="center" valign="middle">
             <h2>Please, wait...</h2>
           </td>
         </tr>
       </table>
    </div>
  </f:view>
 </body>
</html>  

如果你想有一个动画gif图片在"请等待..."中,当表单提交后该图片应该从新加载.因此,再一次指定图片的id,并且添加经过一段时间延时后重新加载的代码.下面是个例子:

<script>
 function gowait() {
   document.getElementById("main").style.visibility="hidden";
   document.getElementById("wait").style.visibility="visible";
   window.setTimeout('showProgress()', 500);
 }
  function showProgress(){ 
   var wg = document.getElementById("waitgif");
   wg.src=wg.src;
 }
</script>
....
....
....
 
<img id="waitgif" src="animated.gif">

使用backing bean来添加UIComponents 到页面中?

<%@taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
<%@taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<html>
<f:view>
<head>
<title>jsp1</title>
  <link rel="stylesheet" type="text/css" href="./style.css" title="Style"/>
</head>
<body bgcolor="#ffffff">  TESTING...
  <h:form id="form1">
    <h:panelGrid id="panelgridtest" binding="#{jsp1Bean.component}"/>
  </h:form>
</body>
</f:view>
</html>

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE faces-config PUBLIC "-//Sun Microsystems, Inc.//DTD JavaServer Faces Config 1.1//EN"
                              "http://java.sun.com/dtd/web-facesconfig_1_1.dtd">
<faces-config>
  <navigation-rule>
    <from-view-id>/jsp1</from-view-id>
    <navigation-case>
      <from-action>submit</from-action>
      <to-view-id>/jsp1</to-view-id>
      <redirect/>
    </navigation-case>
  </navigation-rule>
  <managed-bean>
    <managed-bean-name>jsp1Bean</managed-bean-name>
    <managed-bean-class>test.Jsp1Bean</managed-bean-class>
    <managed-bean-scope>session</managed-bean-scope>
  </managed-bean>
</faces-config>

如何在BackBean中使用SelectMany 对象?

 <managed-bean>
  <managed-bean-name>Manager</managed-bean-name>
 <managed-bean-class>demo.Manager</managed-bean-class>
  <managed-bean-scope>request</managed-bean-scope>
 <managed-bean>

<h:selectManyMenu binding="#{Manager.list}">

How to foward to another JSP from an actionListener ActionEvent

如何为每一个错误消息显示一个图片

<div align="center">
 <h:messages id="errMsgs" styleClass="errorFeedback" layout="table" />
</div>

  errorFeedback style class 可能是下面的代码:

.errorFeedback {
 color: black;
 vertical-align: middle;
 background-image: url(/AccountSetup/images/warning_feedback.gif);
 background-repeat: no-repeat;
 background-position: left top;
 font-family: Verdana, Arial, Helvetica, sans-serif;
 font-weight: bold;
 line-height: 18px;
 font-size: 10pt;
 text-align: left;
 text-indent: 22px;}

(转) 从 Filter和Servlet中如何访问FacesContext?

J2EE 全面简介(转载)

本文从五个方面对J2EE进行了比较全面的介绍。从J2EE的概念说起，到它的优势，到J2EE典型的四层模型，和它的框架结构，最后是J2EE十三种核心技术的一个简介。本文分门别类的对J2EE中的服务，组件，层次，容器，API都做了比较详细的介绍，相信看完此文，读者会对J2EE有一个更清晰的认识。

J2EE的概念

目前，Java 2平台有3个版本，它们是适用于小型设备和智能卡的Java 2平台Micro版（Java 2 Platform Micro Edition，J2ME）、适用于桌面系统的Java 2平台标准版（Java 2 Platform Standard Edition，J2SE）、适用于创建服务器应用程序和服务的Java 2平台企业版（Java 2 Platform Enterprise Edition，J2EE）。

J2EE是一种利用Java 2平台来简化企业解决方案的开发、部署和管理相关的复杂问题的体系结构。J2EE技术的基础就是核心Java平台或Java 2平台的标准版，J2EE不仅巩固了标准版中的许多优点，例如"编写一次、随处运行"的特性、方便存取数据库的JDBC API、CORBA技术以及能够在Internet应用中保护数据的安全模式等等，同时还提供了对 EJB（Enterprise JavaBeans）、Java Servlets API、JSP（Java Server Pages）以及XML技术的全面支持。其最终目的就是成为一个能够使企业开发者大幅缩短投放市场时间的体系结构。

J2EE体系结构提供中间层集成框架用来满足无需太多费用而又需要高可用性、高可靠性以及可扩展性的应用的需求。通过提供统一的开发平台，J2EE降低了开发多层应用的费用和复杂性，同时提供对现有应用程序集成强有力支持，完全支持Enterprise JavaBeans，有良好的向导支持打包和部署应用，添加目录支持，增强了安全机制，提高了性能。

回页首

J2EE的优势

J2EE为搭建具有可伸缩性、灵活性、易维护性的商务系统提供了良好的机制:

1. 保留现存的IT资产: 由于企业必须适应新的商业需求，利用已有的企业信息系统方面的投资，而不是重新制定全盘方案就变得很重要。这样，一个以渐进的（而不是激进的，全盘否定的）方式建立在已有系统之上的服务器端平台机制是公司所需求的。J2EE架构可以充分利用用户原有的投资，如一些公司使用的BEA Tuxedo、IBM CICS, IBM Encina,、Inprise VisiBroker 以及Netscape Application Server。这之所以成为可能是因为J2EE拥有广泛的业界支持和一些重要的'企业计算'领域供应商的参与。每一个供应商都对现有的客户提供了不用废弃已有投资，进入可移植的J2EE领域的升级途径。由于基于J2EE平台的产品几乎能够在任何操作系统和硬件配置上运行，现有的操作系统和硬件也能被保留使用。
2. 高效的开发: J2EE允许公司把一些通用的、很繁琐的服务端任务交给中间件供应商去完成。这样开发人员可以集中精力在如何创建商业逻辑上，相应地缩短了开发时间。高级中间件供应商提供以下这些复杂的中间件服务:
   • 状态管理服务 -- 让开发人员写更少的代码，不用关心如何管理状态，这样能够更快地完成程序开发。
   • 持续性服务 -- 让开发人员不用对数据访问逻辑进行编码就能编写应用程序，能生成更轻巧，与数据库无关的应用程序，这种应用程序更易于开发与维护。
   • 分布式共享数据对象CACHE服务 -- 让开发人员编制高性能的系统，极大提高整体部署的伸缩性。
3. 支持异构环境: J2EE能够开发部署在异构环境中的可移植程序。基于J2EE的应用程序不依赖任何特定操作系统、中间件、硬件。因此设计合理的基于J2EE的程序只需开发一次就可部署到各种平台。这在典型的异构企业计算环境中是十分关键的。J2EE标准也允许客户订购与J2EE兼容的第三方的现成的组件，把他们部署到异构环境中，节省了由自己制订整个方案所需的费用。
4. 可伸缩性: 企业必须要选择一种服务器端平台，这种平台应能提供极佳的可伸缩性去满足那些在他们系统上进行商业运作的大批新客户。基于J2EE平台的应用程序可被部署到各种操作系统上。例如可被部署到高端UNIX与大型机系统，这种系统单机可支持64至256个处理器。（这是NT服务器所望尘莫及的）J2EE领域的供应商提供了更为广泛的负载平衡策略。能消除系统中的瓶颈，允许多台服务器集成部署。这种部署可达数千个处理器，实现可高度伸缩的系统，满足未来商业应用的需要。
5. 稳定的可用性: 一个服务器端平台必须能全天候运转以满足公司客户、合作伙伴的需要。因为INTERNET是全球化的、无处不在的，即使在夜间按计划停机也可能造成严重损失。若是意外停机，那会有灾难性后果。J2EE部署到可靠的操作环境中，他们支持长期的可用性。一些J2EE部署在WINDOWS环境中，客户也可选择健壮性能更好的操作系统如Sun Solaris、IBM OS/390。最健壮的操作系统可达到99.999%的可用性或每年只需5分钟停机时间。这是实时性很强商业系统理想的选择。

回页首

J2EE 的四层模型

J2EE使用多层的分布式应用模型，应用逻辑按功能划分为组件，各个应用组件根据他们所在的层分布在不同的机器上。事实上，sun设计J2EE的初衷正是为了解决两层模式(client/server)的弊端，在传统模式中，客户端担当了过多的角色而显得臃肿，在这种模式中，第一次部署的时候比较容易，但难于升级或改进，可伸展性也不理想，而且经常基于某种专有的协议�D�D通常是某种数据库协议。它使得重用业务逻辑和界面逻辑非常困难。现在J2EE 的多层企业级应用模型将两层化模型中的不同层面切分成许多层。一个多层化应用能够为不同的每种服务提供一个独立的层，以下是 J2EE 典型的四层结构:

• 运行在客户端机器上的客户层组件
• 运行在J2EE服务器上的Web层组件
• 运行在J2EE服务器上的业务逻辑层组件
• 运行在EIS服务器上的企业信息系统(Enterprise information system)层软件

J2EE应用程序组件
J2EE应用程序是由组件构成的.J2EE组件是具有独立功能的软件单元，它们通过相关的类和文件组装成J2EE应用程序，并与其他组件交互。J2EE说明书中定义了以下的J2EE组件:

• 应用客户端程序和applets是客户层组件.
• Java Servlet和JavaServer Pages(JSP)是web层组件.
• Enterprise JavaBeans(EJB)是业务层组件.

客户层组件
J2EE应用程序可以是基于web方式的,也可以是基于传统方式的.

web 层组件
J2EE web层组件可以是JSP 页面或Servlets.按照J2EE规范，静态的HTML页面和Applets不算是web层组件。

正如下图所示的客户层那样，web层可能包含某些 JavaBean 对象来处理用户输入，并把输入发送给运行在业务层上的enterprise bean 来进行处理。

业务层组件
业务层代码的逻辑用来满足银行，零售，金融等特殊商务领域的需要,由运行在业务层上的enterprise bean 进行处理. 下图表明了一个enterprise bean 是如何从客户端程序接收数据，进行处理(如果必要的话), 并发送到EIS 层储存的，这个过程也可以逆向进行。

有三种企业级的bean: 会话(session) beans, 实体(entity) beans, 和消息驱动(message-driven) beans. 会话bean 表示与客户端程序的临时交互. 当客户端程序执行完后, 会话bean 和相关数据就会消失. 相反, 实体bean 表示数据库的表中一行永久的记录. 当客户端程序中止或服务器关闭时, 就会有潜在的服务保证实体bean 的数据得以保存.消息驱动 bean 结合了会话bean 和 JMS的消息监听器的特性, 允许一个业务层组件异步接收JMS 消息.

企业信息系统层
企业信息系统层处理企业信息系统软件包括企业基础建设系统例如企业资源计划 (ERP), 大型机事务处理, 数据库系统,和其它的遗留信息系统. 例如，J2EE 应用组件可能为了数据库连接需要访问企业信息系统

回页首

J2EE 的结构

这种基于组件，具有平台无关性的J2EE 结构使得J2EE 程序的编写十分简单，因为业务逻辑被封装成可复用的组件，并且J2EE 服务器以容器的形式为所有的组件类型提供后台服务. 因为你不用自己开发这种服务, 所以你可以集中精力解决手头的业务问题.

容器和服务
容器设置定制了J2EE服务器所提供得内在支持，包括安全，事务管理，JNDI(Java Naming and Directory Interface)寻址,远程连接等服务，以下列出最重要的几种服务：

• J2EE安全(Security)模型可以让你配置 web 组件或enterprise bean ,这样只有被授权的用户才能访问系统资源. 每一客户属于一个特别的角色，而每个角色只允许激活特定的方法。你应在enterprise bean的布置描述中声明角色和可被激活的方法。由于这种声明性的方法，你不必编写加强安全性的规则。
• J2EE 事务管理（Transaction Management）模型让你指定组成一个事务中所有方法间的关系，这样一个事务中的所有方法被当成一个单一的单元. 当客户端激活一个enterprise bean中的方法，容器介入一管理事务。因有容器管理事务，在enterprise bean中不必对事务的边界进行编码。要求控制分布式事务的代码会非常复杂。你只需在布置描述文件中声明enterprise bean的事务属性，而不用编写并调试复杂的代码。容器将读此文件并为你处理此enterprise bean的事务。
• JNDI 寻址(JNDI Lookup)服务向企业内的多重名字和目录服务提供了一个统一的接口,这样应用程序组件可以访问名字和目录服务.
• J2EE远程连接（Remote Client Connectivity）模型管理客户端和enterprise bean间的低层交互. 当一个enterprise bean创建后, 一个客户端可以调用它的方法就象它和客户端位于同一虚拟机上一样.
• 生存周期管理（Life Cycle Management）模型管理enterprise bean的创建和移除,一个enterprise bean在其生存周期中将会历经几种状态。容器创建enterprise bean，并在可用实例池与活动状态中移动他，而最终将其从容器中移除。即使可以调用enterprise bean的create及remove方法，容器也将会在后台执行这些任务。
• 数据库连接池（Database Connection Pooling）模型是一个有价值的资源。获取数据库连接是一项耗时的工作，而且连接数非常有限。容器通过管理连接池来缓和这些问题。enterprise bean可从池中迅速获取连接。在bean释放连接之可为其他bean使用。

容器类型
J2EE应用组件可以安装部署到以下几种容器中去:

• EJB 容器管理所有J2EE 应用程序中企业级bean 的执行. enterprise bean 和它们的容器运行在J2EE 服务器上.
• Web 容器管理所有J2EE 应用程序中JSP页面和Servlet组件的执行. Web 组件和它们的容器运行在J2EE 服务器上.
• 应用程序客户端容器管理所有J2EE应用程序中应用程序客户端组件的执行. 应用程序客户端和它们的容器运行在J2EE 服务器上.
• Applet 容器是运行在客户端机器上的web浏览器和 Java 插件的结合.

回页首

J2EE的核心API与组件

J2EE平台由一整套服务（Services）、应用程序接口（APIs）和协议构成，它对开发基于Web的多层应用提供了功能支持，下面对J2EE中的13种技术规范进行简单的描述(限于篇幅，这里只能进行简单的描述):

1. JDBC(Java Database Connectivity): JDBC API为访问不同的数据库提供了一种统一的途径，象ODBC一样，JDBC对开发者屏蔽了一些细节问题，另外，JDCB对数据库的访问也具有平台无关性。
2. JNDI(Java Name and Directory Interface): JNDI API被用于执行名字和目录服务。它提供了一致的模型来存取和操作企业级的资源如DNS和LDAP，本地文件系统，或应用服务器中的对象。
3. EJB(Enterprise JavaBean): J2EE技术之所以赢得某体广泛重视的原因之一就是EJB。它们提供了一个框架来开发和实施分布式商务逻辑，由此很显著地简化了具有可伸缩性和高度复杂的企业级应用的开发。EJB规范定义了EJB组件在何时如何与它们的容器进行交互作用。容器负责提供公用的服务，例如目录服务、事务管理、安全性、资源缓冲池以及容错性。但这里值得注意的是，EJB并不是实现J2EE的唯一途径。正是由于J2EE的开放性，使得有的厂商能够以一种和EJB平行的方式来达到同样的目的。
4. RMI(Remote Method Invoke): 正如其名字所表示的那样，RMI协议调用远程对象上方法。它使用了序列化方式在客户端和服务器端传递数据。RMI是一种被EJB使用的更底层的协议。
5. Java IDL/CORBA: 在Java IDL的支持下，开发人员可以将Java和CORBA集成在一起。他们可以创建Java对象并使之可在CORBA ORB中展开, 或者他们还可以创建Java类并作为和其它ORB一起展开的CORBA对象的客户。后一种方法提供了另外一种途径，通过它Java可以被用于将你的新的应用和旧的系统相集成。
6. JSP(Java Server Pages): JSP页面由HTML代码和嵌入其中的Java代码所组成。服务器在页面被客户端所请求以后对这些Java代码进行处理，然后将生成的HTML页面返回给客户端的浏览器。
7. Java Servlet: Servlet是一种小型的Java程序，它扩展了Web服务器的功能。作为一种服务器端的应用，当被请求时开始执行，这和CGI Perl脚本很相似。Servlet提供的功能大多与JSP类似，不过实现的方式不同。JSP通常是大多数HTML代码中嵌入少量的Java代码，而servlets全部由Java写成并且生成HTML。
8. XML(Extensible Markup Language): XML是一种可以用来定义其它标记语言的语言。它被用来在不同的商务过程中共享数据。XML的发展和Java是相互独立的，但是，它和Java具有的相同目标正是平台独立性。通过将Java和XML的组合，您可以得到一个完美的具有平台独立性的解决方案。
9. JMS(Java Message Service): MS是用于和面向消息的中间件相互通信的应用程序接口(API)。它既支持点对点的域，有支持发布/订阅(publish/subscribe)类型的域，并且提供对下列类型的支持：经认可的消息传递,事务型消息的传递，一致性消息和具有持久性的订阅者支持。JMS还提供了另一种方式来对您的应用与旧的后台系统相集成。
10. JTA(Java Transaction Architecture): JTA定义了一种标准的API，应用系统由此可以访问各种事务监控。
11. JTS(Java Transaction Service): JTS是CORBA OTS事务监控的基本的实现。JTS规定了事务管理器的实现方式。该事务管理器是在高层支持Java Transaction API (JTA)规范，并且在较底层实现OMG OTS specification的Java映像。JTS事务管理器为应用服务器、资源管理器、独立的应用以及通信资源管理器提供了事务服务。
12. JavaMail: JavaMail是用于存取邮件服务器的API，它提供了一套邮件服务器的抽象类。不仅支持SMTP服务器，也支持IMAP服务器。
13. JTA(JavaBeans Activation Framework): JavaMail利用JAF来处理MIME编码的邮件附件。MIME的字节流可以被转换成Java对象，或者转换自Java对象。大多数应用都可以不需要直接使用JAF。

from:http://www.javaeye.com/topic/9706

数据库对象的缓存策略

前言
本文探讨Jive(曾经开源的Java论坛)和Hibernate（Java开源持久层）的数据库对象的缓存策略，并阐述作者本人的Lightor（Java开源持久层）采用的数据库对象缓存策略。
本文的探讨基于以前开源的Jive代码，Hibernate2.1.7源码，和作者本人的Lightor代码。
本文用ID (Identifier的缩写)来代表数据记录的关键字。
数据对象查询一般分为两种：条件查询，返回一个满足条件的数据对象列表； ID查询，返回ID对应的数据对象。
本文主要探讨“条件查询”和“ID查询”这两种情况的缓存策略。
本文只探讨一个JVM内的数据缓存策略，不涉及分布式缓存；本文只探讨对应单表的数据对象的缓存，不涉及关联表对象的情况。

一、Jive的缓存策略
1．Jive的缓存策略的过程描述：
(1)条件查询的时候，Jive用 select id from table_name where …. （只选择ID字段）这样的SQL语句查询数据库，来获得一个ID列表。
(2) Jive根据ID列表中的每个ID，首先查看缓存中是否存在对应ID的数据对象：如果存在，那么直接取出，加入到 结果列表中；如果不存在，那么通过一条select * from table_name where id = {ID value} 这样的SQL查询数据库，取出对应的数据对象，放入到结果列表，并把这个数据对象按照ID放入到缓存中。
(3) ID查询的时候，Jive执行类似第(2)步的过程，先从缓存中查找该ID，查不到，再查询数据库，然后把结果放入到缓存。
(4) 删除、更新、增加数据的时候，同时更新缓存。
2．Jive缓存策略的优点：
(1) ID查询的时候，如果该ID已经存在于缓存中，那么可以直接取出。节省了一条数据库查询。
(2) 当多次条件查询的结果集相交的情况下，交集里面的数据对象不用重复从数据库整个获取，直接从缓存中获取即可。
比如，第一次查询的ID列表为{1, 2}，然后根据ID列表的ID从数据库中一个一个取出数据对象，结果集为{a(id = 1), b(id = 2)}。
下一次查询的ID列表为{2, 3}，由于ID = 2的数据对象已经存在于缓存中，那么只要从数据库中取出ID = 3的数据对象即可。
3．Jive缓存策略的缺点：
(1) 在根据条件查找数据对象列表的过程中，DAO的第(1)步用来获得ID列表的那一次数据库查询，是必不可少的。
(2) 如果第(1)步返回的ID列表中有n个ID，在最坏的命中率（缓存中一个对应ID都没有）情况下，Jive还要再查询n次数据库。最坏情况下，共需要n + 1数据库查询。

二、Hibernate的二级缓存策略
Hibernate用Session类包装了数据库连接从打开到关闭的过程。
Session内部维护一个数据对象集合，包括了本Session内选取的、操作的数据对象。这称为Session内部缓存，是Hibernate的第一级最快缓存，属于Hibernate的既定行为，不需要进行配置(也没有办法配置 :-)。
Session的生命期很短，存在于Session内部的第一级最快缓存的生命期当然也很短，命中率自然也很低。当然，这个Session内部缓存的主要作用是保持Session内部数据状态同步。
如果需要跨Session的命中率较高的全局缓存，那么必须对Hibernate进行二级缓存配置。一般来说，同样数据类型（Class）的数据对象，共用一个二级缓存（或其中的同一块）。
1．Hibernate二级缓存策略的过程描述：
(1)条件查询的时候，总是发出一条select * from table_name where …. （选择所有字段）这样的SQL语句查询数据库，一次获得所有的数据对象。
(2) 把获得的所有数据对象根据ID放入到第二级缓存中。
(3) 当Hibernate根据ID访问数据对象的时候，首先从Session一级缓存中查；查不到，如果配置了二级缓存，那么从二级缓存中查；查不到，再查询数据库，把结果按照ID放入到缓存。
(4) 删除、更新、增加数据的时候，同时更新缓存。

2．Hibernate二级缓存策略的优点：
(1) 具有Jive缓存策略同样的第(1)条优点：ID查询的时候，如果该ID已经存在于缓存中，那么可以直接取出。节省了一条数据库查询。
(2) 不具有Jive缓存策略的第(2)条缺点，即hibernate不会有最坏情况下的 n + 1次数据库查询。
3．Hibernate二级缓存策略的缺点：
(1) 同Jive缓存策略的第(1)条缺点一样，条件查询的时候，第(1)步的数据库查询语句是不可少的。而且Hibernate选择所有的字段，比只选择ID字段花费的时间和空间都多。
(2) 不具备Jive缓存策略的第(2)条优点。条件查询的时候，必须把数据库对象从数据库中整个取出，即使该数据库的ID已经存在于缓存中。

三、Hibernate的Query缓存策略
可以看到，Jive缓存和Hibernate的二级缓存策略，都只是针对于ID查询的缓存策略，对于条件查询则毫无作用。（尽管Jive缓存的第(2)个优点，能够避免重复从数据库获取同一个ID对应的数据对象，但select id from …这条数据库查询是每次条件查询都必不可少的）。
为此，Hibernate提供了针对条件查询的Query缓存。
1．Hibernate的Query缓存策略的过程描述：
(1) 条件查询的请求一般都包括如下信息：SQL, SQL需要的参数，记录范围（起始位置rowStart，最大记录个数maxRows)，等。
(2) Hibernate首先根据这些信息组成一个Query Key，根据这个Query Key到Query缓存中查找对应的结果列表。如果存在，那么返回这个结果列表；如果不存在，查询数据库，获取结果列表，把整个结果列表根据Query Key放入到Query缓存中。
(3) Query Key中的SQL涉及到一些表名，如果这些表的任何数据发生修改、删除、增加等操作，这些相关的Query Key都要从缓存中清空。
2．Hibernate的Query缓存策略的优点
(1) 条件查询的时候，如果Query Key已经存在于缓存，那么不需要再查询数据库。命中的情况下，一次数据库查询也不需要。
3．Hibernate的Query缓存策略的缺点
(1) 条件查询涉及到的表中，如果有任何一条记录增加、删除、或改变，那么缓存中所有和该表相关的Query Key都会失效。
比如，有这样几组Query Key，它们的SQL里面都包括table1。
SQL = select * from table1 where c1 = ? …., parameter = 1, rowStart = 11, maxRows = 20.
SQL = select * from table1 where c1 = ? …., parameter = 1, rowStart = 21, maxRows = 20.
SQL = select * from table1 where c1 = ? ….., parameter = 2, rowStart = 11, maxRows = 20.
SQL = select * from table1 where c1 = ? ….., parameter = 2, rowStart = 11, maxRows = 20.
SQL = select * from table1 where c2 = ? …., parameter = ‘abc’, rowStart = 11, maxRows = 20.

当table1的任何数据对象（任何字段）改变、增加、删除的时候，这些Query Key对应的结果集都不能保证没有发生变化。
很难做到根据数据对象的改动精确判断哪些Query Key对应的结果集受到影响。最简单的实现方法，就是清空所有SQL包含table1的Query Key。

(2) Query缓存中，Query Key对应的是数据对象列表，假如不同的Query Key对应的数据对象列表有交集，那么，交集部分的数据对象就是重复存储的。
比如，Query Key 1对应的数据对象列表为{a(id = 1), b(id = 2)}，Query Key 2对应的数据对象列表为{a(id = 1), c(id = 3)}，这个a就在两个List同时存在了两份。

4．二级缓存和Query缓存同步的困惑
假如，Query缓存中，一个Query Key对应的结果列表为{a (id = 1) , b (id = 2), c (id = 3)}; 二级缓存里面有也id = 1对应的数据对象a。
这两个数据对象a之间是什么关系？能够保持状态同步吗？
我阅读Hibernate的相关源码，没有发现两个缓存之间的这种同步关系。
或者两者之间毫无关系。就像我上面所说的，只要表数据发生变化，相关的Query Key都要被清空。所以不用考虑同步问题？

四、Lightor的缓存策略
Lightor是我做的Java开源持久层框架。Lightor的意思是，Lightweight O/R。Hibernate，JDO，EJB CMP这些持久层框架，都是Layer。Lightor算不上Layer，而只是一个Helper。这里的O/R意思不是Object/Relational，而是Object/ResultSet的意思。:-)
Lightor的缓存策略，主要参照Hibernate的缓存思路，Lightor的缓存也分为 Query缓存和ID缓存。但其中有一点不同，两者之间并不是毫无联系的，而是相互关联的。
1．Lightor的缓存策略的过程描述：
(1) 条件查询的请求一般都包括如下信息：SQL, 对应SQL的参数，起始记录位置(rowStart)，最大记录个数(maxRows)，等。
(2) Lightor首先根据这些信息组成一个Query Key，根据这个Query Key到Query缓存中查找对应的结果ID列表。注意，这里获取的是ID列表。
如果结果ID列表存在于Query缓存，那么根据这个ID列表的每个ID，到ID缓存中取对应的数据对象。如果所有ID对应的数据对象都找到，那个返回这个数据对象结果列表。注意，这里获取的是整个数据对象（所有字段）的列表。
如果结果ID列表不存在于Query缓存，或者结果ID列表中的某一个ID不存在于ID缓存，那么，就查询数据库，获取结果列表。然后，把获取的每个数据对象按照ID放入到ID缓存；并组装成一个ID列表，按照Query Key存放到Query缓存中。注意，这里是把ID列表，而不是整个对象列表，放入到Query缓存中。
(3) ID查询的时候，Lightor先从ID缓存中查找该ID，如果不存在，那么查询数据库，把结果放入ID缓存。
(4) Query Key中的SQL涉及到一些表名，如果这些表的任何数据发生修改、删除、增加等操作，这些相关的Query Key都要从缓存中清空。
2．Lightor的缓存策略的优点
(1) Lightor的ID缓存具有Jive缓存，和Hibernate二级ID缓存的优点。ID查询的时候，如果该ID已经存在于缓存中，那么可以直接取出。节省了一条数据库查询。
(2) Lightor的Query缓存具有Hibernate的Query缓存的优点。条件查询的时候，如果Query Key已经存在于缓存，那么不需要再查询数据库。命中的情况下，一次数据库查询也不需要。
(3) Lightor的Query缓存中，Query Key对应的是ID列表，而不是数据对象列表，真正的数据对象只存在于ID缓存中。所以，不同的Query Key对应的ID列表如果有交集，ID对应的数据对象也不会在ID缓存中重复存储。
(4) Lightor的缓存也没有Jive缓存的最坏情况n + 1次数据库查询缺点。
3．Lightor的缓存策略的缺点
(1) Lightor的Query缓存具有Hibernate的Query缓存的缺点。条件查询涉及到的表中，如果有任何一条记录增加、删除、或改变，那么缓存中所有和该表相关的Query Key都会失效。
(2) Lightor的ID缓存也具有hibernate的二级ID缓存具有的缺点。条件查询的时候，即使ID已经存在于缓存中，也需要重新把数据对象整个从数据库取出，放入到缓存中。

五、Query Key的效率
Query缓存的Query Key的空间和时间开销比较大。
Query Key里面存放的东西不少，SQL, 参数，范围（起始，个数）。
这里面最大的东西就是SQL。又占地方，又花时间（hashCode, equals）。
Query Key最关键的两个方法是hashCode和equals，重点是SQL的hashCode和equals。

Lightor的做法是，由于Lightor直接使用SQL，不用HQL、OQL之类，所以推荐尽量使用static final String的SQL，能够节省空间和时间，以至于Query Key的效率能够相当于ID Key的效率。
至于Hibernate的QueryKey，有兴趣的读者可以去下载阅读Hibernate的各个版本的源代码，跟踪一下QueryKey的实现优化过程。

六、总结
这里列一个表，综合表示Jive, Hibernate, Lightor的缓存策略的特征。
N + 1问题 重复ID缓存问题 Query缓存支持
Jive缓存 有 无 不支持
Hibernate缓存 无 有 支持
Lightor缓存 无 有 支持

注：
“重复ID缓存问题”的含义是，每次条件查询，不是只取ID列表，而是取出完整对象（所有字段）的列表。这样，同一个ID对应的数据对象，即使在缓存中已经存在，也可能被重新放入缓存。参见相关缓存的缺点描述。
“重复ID缓存问题”的负面效应到底有多大，就看你的select id from …（只选择ID）比你的 select * from … (选择所有字段)快多少。主要影响因素是，字段的个数，字段值的长度，与数据库服务器之间网络传输速度。
不管怎么说，即使选择所有字段，也只是一次数据库查询。而N + 1问题带来的可能最坏的负面效应（N + 1次数据查询）却是非常大的。
选择缓存策略的时候，应根据这些情况发生的概率和正负面效应进行取舍。

----- added later

看到Robbin在04年6月的一篇相关文章。

Hibernate Iterator JCS分析
http://www.hibernate.org.cn/71.html

线性表，链表，哈希表是常用的数据结构，在进行Java开发时，JDK已经为我们提供了一系列相应的类来实现基本的数据结构。这些类均在java.util包中。本文试图通过简单的描述，向读者阐述各个类的作用以及如何正确使用这些类。

Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│　└Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap

Collection接口
　　Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。
　　所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。
　　如何遍历Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下：
　　　　Iterator it = collection.iterator(); // 获得一个迭代子
　　　　while(it.hasNext()) {
　　　　　　Object obj = it.next(); // 得到下一个元素
　　　　}
　　由Collection接口派生的两个接口是List和Set。

List接口
　　List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。
和下面要提到的Set不同，List允许有相同的元素。
　　除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，还能向前或向后遍历。
　　实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。

LinkedList类
　　LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。
　　注意LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：
　　　　List list = Collections.synchronizedList(new LinkedList(...));

ArrayList类
　　ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。
size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。
　　每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
　　和LinkedList一样，ArrayList也是非同步的（unsynchronized）。

Vector类
　　Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的Iterator，虽然和ArrayList创建的Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常。

Stack 类
　　Stack继承自Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方法，还有peek方法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。

Set接口
　　Set是一种不包含重复的元素的Collection，即任意的两个元素e1和e2都有e1.equals(e2)=false，Set最多有一个null元素。
　　很明显，Set的构造函数有一个约束条件，传入的Collection参数不能包含重复的元素。
　　请注意：必须小心操作可变对象（Mutable Object）。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。

Map接口
　　请注意，Map没有继承Collection接口，Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个value。Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射。

Hashtable类
　　Hashtable继承Map接口，实现一个key-value映射的哈希表。任何非空（non-null）的对象都可作为key或者value。
　　添加数据使用put(key, value)，取出数据使用get(key)，这两个基本操作的时间开销为常数。
Hashtable通过initial capacity和load factor两个参数调整性能。通常缺省的load factor 0.75较好地实现了时间和空间的均衡。增大load factor可以节省空间但相应的查找时间将增大，这会影响像get和put这样的操作。
使用Hashtable的简单示例如下，将1，2，3放到Hashtable中，他们的key分别是”one”，”two”，”three”：
　　　　Hashtable numbers = new Hashtable();
　　　　numbers.put(“one”, new Integer(1));
　　　　numbers.put(“two”, new Integer(2));
　　　　numbers.put(“three”, new Integer(3));
　　要取出一个数，比如2，用相应的key：
　　　　Integer n = (Integer)numbers.get(“two”);
　　　　System.out.println(“two = ” + n);
　　由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置，因此任何作为key的对象都必须实现hashCode和equals方法。hashCode和equals方法继承自根类Object，如果你用自定义的类当作key的话，要相当小心，按照散列函数的定义，如果两个对象相同，即obj1.equals(obj2)=true，则它们的hashCode必须相同，但如果两个对象不同，则它们的hashCode不一定不同，如果两个不同对象的hashCode相同，这种现象称为冲突，冲突会导致操作哈希表的时间开销增大，所以尽量定义好的hashCode()方法，能加快哈希表的操作。
　　如果相同的对象有不同的hashCode，对哈希表的操作会出现意想不到的结果（期待的get方法返回null），要避免这种问题，只需要牢记一条：要同时复写equals方法和hashCode方法，而不要只写其中一个。
　　Hashtable是同步的。

HashMap类
　　HashMap和Hashtable类似，不同之处在于HashMap是非同步的，并且允许null，即null value和null key。，但是将HashMap视为Collection时（values()方法可返回Collection），其迭代子操作时间开销和HashMap的容量成比例。因此，如果迭代操作的性能相当重要的话，不要将HashMap的初始化容量设得过高，或者load factor过低。

WeakHashMap类
　　WeakHashMap是一种改进的HashMap，它对key实行“弱引用”，如果一个key不再被外部所引用，那么该key可以被GC回收。

总结
　　如果涉及到堆栈，队列等操作，应该考虑用List，对于需要快速插入，删除元素，应该使用LinkedList，如果需要快速随机访问元素，应该使用ArrayList。
　　如果程序在单线程环境中，或者访问仅仅在一个线程中进行，考虑非同步的类，其效率较高，如果多个线程可能同时操作一个类，应该使用同步的类。
　　要特别注意对哈希表的操作，作为key的对象要正确复写equals和hashCode方法。
　　尽量返回接口而非实际的类型，如返回List而非ArrayList，这样如果以后需要将ArrayList换成LinkedList时，客户端代码不用改变。这就是针对抽象编程。

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

引言

    正则表达式（regular expression）描述了一种字符串匹配的模式，可以用来：（1）检查一个串中是否含有符合某个规则的子串，并且可以得到这个子串；（2）根据匹配规则对字符串进行灵活的替换操作。

    正则表达式学习起来其实是很简单的，不多的几个较为抽象的概念也很容易理解。之所以很多人感觉正则表达式比较复杂，一方面是因为大多数的文档没有做到由浅 入深地讲解，概念上没有注意先后顺序，给读者的理解带来困难；另一方面，各种引擎自带的文档一般都要介绍它特有的功能，然而这部分特有的功能并不是我们首 先要理解的。

    文章中的每一个举例，都可以点击进入到测试页面进行测试。闲话少说，开始。

1. 正则表达式规则

1.1 普通字符

    字母、数字、汉字、下划线、以及后边章节中没有特殊定义的标点符号，都是"普通字符"。表达式中的普通字符，在匹配一个字符串的时候，匹配与之相同的一个字符。

    举例1：表达式 "c"，在匹配字符串 "abcde" 时，匹配结果是：成功；匹配到的内容是："c"；匹配到的位置是：开始于2，结束于3。（注：下标从0开始还是从1开始，因当前编程语言的不同而可能不同）

    举例2：表达式 "bcd"，在匹配字符串 "abcde" 时，匹配结果是：成功；匹配到的内容是："bcd"；匹配到的位置是：开始于1，结束于4。

1.2 简单的转义字符

    一些不便书写的字符，采用在前面加 "\" 的方法。这些字符其实我们都已经熟知了。

    还有其他一些在后边章节中有特殊用处的标点符号，在前面加 "\" 后，就代表该符号本身。比如：^, $ 都有特殊意义，如果要想匹配字符串中 "^" 和 "$" 字符，则表达式就需要写成 "\^" 和 "\$"。

    这些转义字符的匹配方法与 "普通字符" 是类似的。也是匹配与之相同的一个字符。

    举例1：表达式 "\$d"，在匹配字符串 "abc$de" 时，匹配结果是：成功；匹配到的内容是："$d"；匹配到的位置是：开始于3，结束于5。

1.3 能够与 '多种字符' 匹配的表达式

    正则表达式中的一些表示方法，可以匹配 '多种字符' 其中的任意一个字符。比如，表达式 "\d" 可以匹配任意一个数字。虽然可以匹配其中任意字符，但是只能是一个，不是多个。这就好比玩扑克牌时候，大小王可以代替任意一张牌，但是只能代替一张牌。

    举例1：表达式 "\d\d"，在匹配 "abc123" 时，匹配的结果是：成功；匹配到的内容是："12"；匹配到的位置是：开始于3，结束于5。

    举例2：表达式 "a.\d"，在匹配 "aaa100" 时，匹配的结果是：成功；匹配到的内容是："aa1"；匹配到的位置是：开始于1，结束于4。

1.4 自定义能够匹配 '多种字符' 的表达式

    使用方括号 [ ] 包含一系列字符，能够匹配其中任意一个字符。用 [^ ] 包含一系列字符，则能够匹配其中字符之外的任意一个字符。同样的道理，虽然可以匹配其中任意一个，但是只能是一个，不是多个。

    举例1：表达式 "[bcd][bcd]" 匹配 "abc123" 时，匹配的结果是：成功；匹配到的内容是："bc"；匹配到的位置是：开始于1，结束于3。

    举例2：表达式 "[^abc]" 匹配 "abc123" 时，匹配的结果是：成功；匹配到的内容是："1"；匹配到的位置是：开始于3，结束于4。

1.5 修饰匹配次数的特殊符号

    前面章节中讲到的表达式，无论是只能匹配一种字符的表达式，还是可以匹配多种字符其中任意一个的表达式，都只能匹配一次。如果使用表达式再加上修饰匹配次数的特殊符号，那么不用重复书写表达式就可以重复匹配。

    使用方法是："次数修饰"放在"被修饰的表达式"后边。比如："[bcd][bcd]" 可以写成 "[bcd]{2}"。

    举例1：表达式 "\d+\.?\d*" 在匹配 "It costs $12.5" 时，匹配的结果是：成功；匹配到的内容是："12.5"；匹配到的位置是：开始于10，结束于14。

    举例2：表达式 "go{2,8}gle" 在匹配 "Ads by goooooogle" 时，匹配的结果是：成功；匹配到的内容是："goooooogle"；匹配到的位置是：开始于7，结束于17。

1.6 其他一些代表抽象意义的特殊符号

    一些符号在表达式中代表抽象的特殊意义：

    进一步的文字说明仍然比较抽象，因此，举例帮助大家理解。

    举例1：表达式 "^aaa" 在匹配 "xxx aaa xxx" 时，匹配结果是：失败。因为 "^" 要求与字符串开始的地方匹配，因此，只有当 "aaa" 位于字符串的开头的时候，"^aaa" 才能匹配，比如："aaa xxx xxx"。

    举例2：表达式 "aaa$" 在匹配 "xxx aaa xxx" 时，匹配结果是：失败。因为 "$" 要求与字符串结束的地方匹配，因此，只有当 "aaa" 位于字符串的结尾的时候，"aaa$" 才能匹配，比如："xxx xxx aaa"。

    举例3：表达式 ".\b." 在匹配 "@@@abc" 时，匹配结果是：成功；匹配到的内容是："@a"；匹配到的位置是：开始于2，结束于4。
    进一步说明："\b" 与 "^" 和 "$" 类似，本身不匹配任何字符，但是它要求它在匹配结果中所处位置的左右两边，其中一边是 "\w" 范围，另一边是 非"\w" 的范围。

    举例4：表达式 "\bend\b" 在匹配 "weekend,endfor,end" 时，匹配结果是：成功；匹配到的内容是："end"；匹配到的位置是：开始于15，结束于18。

    一些符号可以影响表达式内部的子表达式之间的关系：

    举例5：表达式 "Tom|Jack" 在匹配字符串 "I'm Tom, he is Jack" 时，匹配结果是：成功；匹配到的内容是："Tom"；匹配到的位置是：开始于4，结束于7。匹配下一个时，匹配结果是：成功；匹配到的内容是："Jack"；匹配到的位置时：开始于15，结束于19。

    举例6：表达式 "(go\s*)+" 在匹配 "Let's go go go!" 时，匹配结果是：成功；匹配到内容是："go go go"；匹配到的位置是：开始于6，结束于14。

    举例7：表达式 "￥(\d+\.?\d*)" 在匹配 "＄10.9,￥20.5" 时，匹配的结果是：成功；匹配到的内容是："￥20.5"；匹配到的位置是：开始于6，结束于10。单独获取括号范围匹配到的内容是："20.5"。

2. 正则表达式中的一些高级规则

2.1 匹配次数中的贪婪与非贪婪

    在使用修饰匹配次数的特殊符号时，有几种表示方法可以使同一个表达式能够匹配不同的次数，比如："{m,n}", "{m,}", "?", "*", "+"，具体匹配的次数随被匹配的字符串而定。这种重复匹配不定次数的表达式在匹配过程中，总是尽可能多的匹配。比如，针对文本 "dxxxdxxxd"，举例如下：

    由此可见，"\w+" 在匹配的时候，总是尽可能多的匹配符合它规则的字符。虽然第二个举例中，它没有匹配最后一个 "d"，但那也是为了让整个表达式能够匹配成功。同理，带 "*" 和 "{m,n}" 的表达式都是尽可能地多匹配，带 "?" 的表达式在可匹配可不匹配的时候，也是尽可能的 "要匹配"。这 种匹配原则就叫作 "贪婪" 模式 。

    非贪婪模式：

    在修饰匹配次数的特殊符号后再加上一个 "?" 号，则可以使匹配次数不定的表达式尽可能少的匹配，使可匹配可不匹配的表达式，尽可能的 "不匹配"。这种匹配原则叫作 "非贪婪" 模式，也叫作 "勉强" 模式。如果少匹配就会导致整个表达式匹配失败的时候，与贪婪模式类似，非贪婪模式会最小限度的再匹配一些，以使整个表达式匹配成功。举例如下，针对文本 "dxxxdxxxd" 举例：

    更多的情况，举例如下：

    举 例1：表达式 "<td>(.*)</td>" 与字符串 "<td><p>aa</p></td> <td><p>bb</p></td>" 匹配时，匹配的结果是：成功；匹配到的内容是 "<td><p>aa</p></td> <td><p>bb</p></td>" 整个字符串， 表达式中的 "</td>" 将与字符串中最后一个 "</td>" 匹配。

    举例2：相比之下，表达式 "<td>(.*?)</td>" 匹配举例1中同样的字符串时，将只得到 "<td><p>aa</p></td>"， 再次匹配下一个时，可以得到第二个 "<td><p>bb</p></td>"。

2.2 反向引用 \1, \2...

    表达式在匹配时，表达式引擎会将小括号 "( )" 包含的表达式所匹配到的字符串记录下来。在获取匹配结果的时候，小括号包含的表达式所匹配到的字符串可以单独获取。这一点，在前面的举例中，已经多次展示 了。在实际应用场合中，当用某种边界来查找，而所要获取的内容又不包含边界时，必须使用小括号来指定所要的范围。比如前面的 "<td>(.*?)</td>"。

    其实，"小括号包含的表达式所匹配到的字符串" 不仅是在匹配结束后才可以使用，在匹配过程中也可以使用。表达式后边的部分，可以引用前面 "括号内的子匹配已经匹配到的字符串"。引用方法是 "\" 加上一个数字。"\1" 引用第1对括号内匹配到的字符串，"\2" 引用第2对括号内匹配到的字符串……以此类推，如果一对括号内包含另一对括号，则外层的括号先排序号。换句话说，哪一对的左括号 "(" 在前，那这一对就先排序号。

    举例如下：

    举例1：表达式 "('|")(.*?)(\1)" 在匹配 " 'Hello', "World" " 时，匹配结果是：成功；匹配到的内容是：" 'Hello' "。再次匹配下一个时，可以匹配到 " "World" "。

    举例2：表达式 "(\w)\1{4,}" 在匹配 "aa bbbb abcdefg ccccc 111121111 999999999" 时，匹配结果是：成功；匹配到的内容是 "ccccc"。再次匹配下一个时，将得到 999999999。这个表达式要求 "\w" 范围的字符至少重复5次，注意与 "\w{5,}" 之间的区别。

    举例3：表达式 "<(\w+)\s*(\w+(=('|").*?\4)?\s*)*>.*?</\1>" 在匹配 "<td id='td1' style="bgcolor:white"></td>" 时，匹配结果是成功。如果 "<td>" 与 "</td>" 不配对，则会匹配失败；如果改成其他配对，也可以匹配成功。

2.3 预搜索，不匹配；反向预搜索，不匹配

    前面的章节中，我讲到了几个代表抽象意义的特殊符号："^"，"$"，"\b"。它们都有一个共同点，那就是：它们本身不匹配任何字符，只是对 "字符串的两头" 或者 "字符之间的缝隙" 附加了一个条件。理解到这个概念以后，本节将继续介绍另外一种对 "两头" 或者 "缝隙" 附加条件的，更加灵活的表示方法。

    正向预搜索："(?=xxxxx)"，"(?!xxxxx)"

    格式："(?=xxxxx)"，在被匹配的字符串中，它对所处的 "缝隙" 或者 "两头" 附加的条件是：所在缝隙的右侧，必须能够匹配上 xxxxx 这部分的表达式。因为它只是在此作为这个缝隙上附加的条件，所以它并不影响后边的表达式去真正匹配这个缝隙之后的字符。这就类似 "\b"，本身不匹配任何字符。"\b" 只是将所在缝隙之前、之后的字符取来进行了一下判断，不会影响后边的表达式来真正的匹配。

    举例1：表达式 "Windows (?=NT|XP)" 在匹配 "Windows 98, Windows NT, Windows 2000" 时，将只匹配 "Windows NT" 中的 "Windows "，其他的 "Windows " 字样则不被匹配。

    举例2：表达式 "(\w)((?=\1\1\1)(\1))+" 在匹配字符串 "aaa ffffff 999999999" 时，将可以匹配6个"f"的前4个，可以匹配9个"9"的前7个。这个表达式可以读解成：重复4次以上的字母数字，则匹配其剩下最后2位之前的部分。当然，这个表达式可以不这样写，在此的目的是作为演示之用。

    格式："(?!xxxxx)"，所在缝隙的右侧，必须不能匹配 xxxxx 这部分表达式。

    举例3：表达式 "((?!\bstop\b).)+" 在匹配 "fdjka ljfdl stop fjdsla fdj" 时，将从头一直匹配到 "stop" 之前的位置，如果字符串中没有 "stop"，则匹配整个字符串。

    举例4：表达式 "do(?!\w)" 在匹配字符串 "done, do, dog" 时，只能匹配 "do"。在本条举例中，"do" 后边使用 "(?!\w)" 和使用 "\b" 效果是一样的。

    反向预搜索："(?<=xxxxx)"，"(?<!xxxxx)"

    这两种格式的概念和正向预搜索是类似的，反向预搜索要求的条件是：所在缝隙的 "左侧"，两种格式分别要求必须能够匹配和必须不能够匹配指定表达式，而不是去判断右侧。与 "正向预搜索" 一样的是：它们都是对所在缝隙的一种附加条件，本身都不匹配任何字符。

    举例5：表达式 "(?<=\d{4})\d+(?=\d{4})" 在匹配 "1234567890123456" 时，将匹配除了前4个数字和后4个数字之外的中间8个数字。由于 JScript.RegExp 不支持反向预搜索，因此，本条举例不能够进行演示。很多其他的引擎可以支持反向预搜索，比如：Java 1.4 以上的 java.util.regex 包，.NET 中System.Text.RegularExpressions 命名空间，boost::regex 以及 GRETA 正则表达式库等。

3. 其他通用规则

    还有一些在各个正则表达式引擎之间比较通用的规则，在前面的讲解过程中没有提到。

3.1 表达式中，可以使用 "\xXX" 和 "\uXXXX" 表示一个字符（"X" 表示一个十六进制数）

3.2 在表达式 "\s"，"\d"，"\w"，"\b" 表示特殊意义的同时，对应的大写字母表示相反的意义

3.3 在表达式中有特殊意义，需要添加 "\" 才能匹配该字符本身的字符汇总

3.4 括号 "( )" 内的子表达式，如果希望匹配结果不进行记录供以后使用，可以使用 "(?:xxxxx)" 格式

    举例1：表达式 "(?:(\w)\1)+" 匹配 "a bbccdd efg" 时，结果是 "bbccdd"。括号 "(?:)" 范围的匹配结果不进行记录，因此 "(\w)" 使用 "\1" 来引用。

3.5 常用的表达式属性设置简介：Ignorecase，Singleline，Multiline，Global

4. 综合提示

4.1 如果要要求表达式所匹配的内容是整个字符串，而不是从字符串中找一部分，那么可以在表达式的首尾使用 "^" 和 "$"，比如："^\d+$" 要求整个字符串只有数字。

4.2 如果要求匹配的内容是一个完整的单词，而不会是单词的一部分，那么在表达式首尾使用 "\b"，比如：使用 "\b(if|while|else|void|int……)\b" 来匹配程序中的关键字。

4.3 表达式不要匹配空字符串。否则会一直得到匹配成功，而结果什么都没有匹配到。比如：准备写一个匹配 "123"、"123."、"123.5"、".5" 这几种形式的表达式时，整数、小数点、小数数字都可以省略，但是不要将表达式写成："\d*\.?\d*"，因为如果什么都没有，这个表达式也可以匹配成 功。更好的写法是："\d+\.?\d*|\.\d+"。

4.4 能匹配空字符串的子匹配不要循环无限次。如果括号内的子表达式中的每一部分都可以匹配 0 次，而这个括号整体又可以匹配无限次，那么情况可能比上一条所说的更严重，匹配过程中可能死循环。虽然现在有些正则表达式引擎已经通过办法避免了这种情况 出现死循环了，比如 .NET 的正则表达式，但是我们仍然应该尽量避免出现这种情况。如果我们在写表达式时遇到了死循环，也可以从这一点入手，查找一下是否是本条所说的原因。

4.5 合理选择贪婪模式与非贪婪模式，参见话题讨论。

4.6 或 "|" 的左右两边，对某个字符最好只有一边可以匹配，这样，不会因为 "|" 两边的表达式因为交换位置而有所不同。