@Override

public String toSting() {   // 注意方法名拼写错了

    return "[" + super.toString() + "]";

}

下面是一段使用@Deprecated的代码：

/**

* 这里是javadoc的@deprecated声明.

* @deprecated No one has players for this format any more.  Use VHS instead.

*/

@Deprecated public class Betamax { ... }

@SuppressWarnings(value={"unchecked","fallthrough"})

public void lintTrap() { /* sloppy method body omitted */ }

@SuppressWarnings({"unchecked","fallthrough"})

@SuppressWarnings("unchecked")

@Reviews({  // Single-value annotation, so "value=" is omitted here

    @Review(grade=Review.Grade.EXCELLENT,

            reviewer="df"),

    @Review(grade=Review.Grade.UNSATISFACTORY,

            reviewer="eg",

            comment="This method needs an @Override annotation")

})

@UncheckedExceptions({

    IllegalArgumentException.class, StringIndexOutOfBoundsException.class

})

/**

* This package holds my custom annotation types.

*/

@com.davidflanagan.annotations.Author("David Flanagan")

package com.davidflanagan.annotations;

import java.lang.reflect.*;



Class c = WhizzBangClass.class;                           

Method m = c.getMethod("whizzy", int.class, int.class);  

boolean unstable = m.isAnnotationPresent(Unstable.class);

AnnotatedElement target = WhizzBangClass.class; //获得被查询的AnnotatedElement

// 查询AnnotatedElement的@Reviews annotation信息

Reviews annotation = target.getAnnotation(Reviews.class);

// 因为@Reviews annotation类型的成员为@Review annotation类型的数组，

// 所以下面声明了Review[] reviews保存@Reviews annotation类型的value成员值。

Review[] reviews = annotation.value();

// 查询每个@Review annotation的成员信息

for(Review r : reviews) {

    Review.Grade grade = r.grade();

    String reviewer = r.reviewer();

    String comment = r.comment();

    System.out.printf("%s assigned a grade of %s and comment '%s'%n",

                      reviewer, grade, comment);

}

package com.davidflanagan.annotations;

import java.lang.annotation.*;



/**

* 使用annotation来描述那些被标注的成员是不稳定的，需要更改

*/

@Retention(RetentionPolicy.RUNTIME)

public @interface Unstable {}

/**

* 使用Author这个annotation定义在程序中指出代码的作者

*/

public @interface Author {

    /** 返回作者名 */

    String value();

}

import java.lang.annotation.*;

        

/**

* Reviews annotation类型只有一个成员，

* 但是这个成员的类型是复杂的：由Review annotation组成的数组

*/

@Retention(RetentionPolicy.RUNTIME)

public @interface Reviews {

    Review[] value();

}



/**

* Review annotation类型有3个成员： 

* 枚举类型成员grade、

  * 表示Review名称的字符串类型成员Reviewer、

  * 具有默认值的字符串类型成员Comment。

*/

public @interface Review {

    // 内嵌的枚举类型

    public static enum Grade { EXCELLENT, SATISFACTORY, UNSATISFACTORY };



    // 下面的方法定义了annotation的成员

    Grade grade();                

    String reviewer();          

    String comment() default "";  

}

public @interface UncheckedExceptions {

    Class<? extends RuntimeException>[] value();

}

平时写程序的时候,很多时候提示文件找不到,而抛出了异常,现在整理如下

一 相对路径的获得
    说明:相对路径(即不写明时候到底相对谁)均可通过以下方式获得（不论是一般的java项目还是web项目）
         String relativelyPath=System.getProperty("user.dir");
         上述相对路径中，java项目中的文件是相对于项目的根目录
         web项目中的文件路径视不同的web服务器不同而不同（tomcat是相对于 tomcat安装目录"bin）


二 类加载目录的获得(即当运行时某一类时获得其装载目录)
      1.1)通用的方法一(不论是一般的java项目还是web项目,先定位到能看到包路径的第一级目录)
       
        InputStream is=TestAction.class.getClassLoader().getResourceAsStream("test.txt");
                  (test.txt文件的路径为  项目名"src"test.txt;类TestAction所在包的第一级目录位于src目录下)
       
        上式中将TestAction，test.txt替换成对应成相应的类名和文件名字即可

        1.2)通用方法二  (此方法和1.1中的方法类似,不同的是此方法必须以'/'开头)
             InputStream is=Test1.class.getResourceAsStream("/test.txt");
                      (test.txt文件的路径为  项目名"src"test.txt,类Test1所在包的第一级目录位于src目录下)

     


三 web项目根目录的获得(发布之后)
    1 从servlet出发

    可建立一个servlet在其的init方法中写入如下语句
      ServletContext s1=this.getServletContext();
     String temp=s1.getRealPath("/"); (关键)
     结果形如：D:"工具"Tomcat-6.0"webapps"002_ext"  (002_ext为项目名字)

                     如果是调用了s1.getRealPath("")则输出D:"工具"Tomcat-6.0"webapps"002_ext(少了一个""")

   2 从httpServletRequest出发

             String cp11111=request.getSession().getServletContext().getRealPath("/");

      结果形如:D:"工具"Tomcat-6.0"webapps"002_ext"

四  classpath的获取(在Eclipse中为获得src或者classes目录的路径)

    方法一   Thread.currentThread().getContextClassLoader().getResource("").getPath()

                      eg: String t=Thread.currentThread().getContextClassLoader().getResource("").getPath();
                      System.out.println("t---"+t);

                      输出:t---/E:/order/002_ext/WebRoot/WEB-INF/classes/

   方法二      JdomParse.class.getClassLoader().getResource("").getPath()   (JdomParse为src某一个包中的类,下同)

                 eg:String p1=JdomParse.class.getClassLoader().getResource("").getPath();
                     System.out.println("JdomParse.class.getClassLoader().getResource--"+p1);

   输出: JdomParse.class.getClassLoader().getResource--/E:/order/002_ext/WebRoot/WEB-INF/classes/

另外,如果想把文件放在某一包中,则可以 通过以下方式获得到文件(先定位到该包的最后一级目录)

        eg  String p2=JdomParse.class.getResource("").getPath();
         System.out.println("JdomParse.class.getResource---"+p2);

   输出: JdomParse.class.getResource---/E:/order/002_ext/WebRoot/WEB-INF/classes/jdom/ (JdomParse为src目录下jdom包中的类)

四   属性文件的读取:

     方法 一

           InputStream in = lnew BufferedInputStream( new  FileInputStream(name));        Properties p = new  Properties();  p.load(in); 

    注意路径的问题,做执行之后就可以调用p.getProperty("name")得到对应属性的值

方法二

        Locale locale = Locale.getDefault(); 
              ResourceBundle localResource = ResourceBundle.getBundle("test/propertiesTest", locale); 
            String value = localResource.getString("test"); 
           System.out.println("ResourceBundle: " + value);

     工程src目录下propertiesTest.properties(名字后缀必须为properties)文件内容如下:

               test=hello word

1.基本概念的理解

　　绝对路径：绝对路径就是你的主页上的文件或目录在硬盘上真正的路径，(URL和物理路径)例如：
C:"xyz"test.txt 代表了test.txt文件的绝对路径。http://www.sun.com/index.htm也代表了一个
URL绝对路径。

　　相对路径：相对与某个基准目录的路径。包含Web的相对路径（HTML中的相对目录），例如：在
Servlet中，"/"代表Web应用的跟目录。和物理路径的相对表示。例如："./" 代表当前目录,
"../"代表上级目录。这种类似的表示，也是属于相对路径。

另外关于URI，URL,URN等内容，请参考RFC相关文档标准。

RFC 2396: Uniform Resource Identifiers (URI): Generic Syntax,
(http://www.ietf.org/rfc/rfc2396.txt)

2.关于JSP/Servlet中的相对路径和绝对路径。

2.1服务器端的地址

　　 服务器端的相对地址指的是相对于你的web应用的地址，这个地址是在服务器端解析的
（不同于html和javascript中的相对地址，他们是由客户端浏览器解析的）也就是说这时候
在jsp和servlet中的相对地址应该是相对于你的web应用，即相对于http://192.168.0.1/webapp/的。

　　其用到的地方有：
 forward：servlet中的request.getRequestDispatcher(address);这个address是
在服务器端解析的，所以，你要forward到a.jsp应该这么写：
request.getRequestDispatcher(“/user/a.jsp”)这个/相对于当前的web应用webapp，
其绝对地址就是：http://192.168.0.1/webapp/user/a.jsp。
sendRedirect：在jsp中<%response.sendRedirect("/rtccp/user/a.jsp");%>

2.22、客户端的地址
 
       所有的html页面中的相对地址都是相对于服务器根目录(http://192.168.0.1/)的，
而不是(跟目录下的该Web应用的目录)http://192.168.0.1/webapp/的。
 Html中的form表单的action属性的地址应该是相对于服务器根目录(http://192.168.0.1/)的，
所以，如果提交到a.jsp为：action＝"/webapp/user/a.jsp"或action="<%=request.getContextPath()%>"/user/a.jsp；
提交到servlet为actiom＝"/webapp/handleservlet"  
 　　Javascript也是在客户端解析的，所以其相对路径和form表单一样。
 

　　因此，一般情况下，在JSP/HTML页面等引用的CSS,Javascript.Action等属性前面最好都加上
<%=request.getContextPath()%>,以确保所引用的文件都属于Web应用中的目录。
另外，应该尽量避免使用类似".","./","../../"等类似的相对该文件位置的相对路径，这样
当文件移动时，很容易出问题。

3. JSP/Servlet中获得当前应用的相对路径和绝对路径
3.1 JSP中获得当前应用的相对路径和绝对路径
 根目录所对应的绝对路径:request.getRequestURI()
 文件的绝对路径    　:application.getRealPath(request.getRequestURI());
 当前web应用的绝对路径 :application.getRealPath("/");
 取得请求文件的上层目录:new File(application.getRealPath(request.getRequestURI())).getParent()

3.2 Servlet中获得当前应用的相对路径和绝对路径
 根目录所对应的绝对路径:request.getServletPath();
 文件的绝对路径    :request.getSession().getServletContext().getRealPath
(request.getRequestURI())   
 当前web应用的绝对路径 :servletConfig.getServletContext().getRealPath("/");
     (ServletContext对象获得几种方式：
       javax.servlet.http.HttpSession.getServletContext()
       javax.servlet.jsp.PageContext.getServletContext()
       javax.servlet.ServletConfig.getServletContext()
     )

4.java 的Class中获得相对路径，绝对路径的方法
4.1单独的Java类中获得绝对路径
根据java.io.File的Doc文挡，可知:
 默认情况下new File("/")代表的目录为：System.getProperty("user.dir")。
 一下程序获得执行类的当前路径
package org.cheng.file;
import java.io.File;

public class FileTest {
    public static void main(String[] args) throws Exception {      

  System.out.println(Thread.currentThread().getContextClassLoader().getResource(""));    

  System.out.println(FileTest.class.getClassLoader().getResource(""));       

　　System.out.println(ClassLoader.getSystemResource(""));       
  System.out.println(FileTest.class.getResource(""));       
  System.out.println(FileTest.class.getResource("/")); //Class文件所在路径 
  System.out.println(new File("/").getAbsolutePath());       
  System.out.println(System.getProperty("user.dir"));   
 }
}

4.2服务器中的Java类获得当前路径（来自网络）
(1).Weblogic

WebApplication的系统文件根目录是你的weblogic安装所在根目录。
例如：如果你的weblogic安装在c:"bea"weblogic700.....
那么，你的文件根路径就是c:".
所以，有两种方式能够让你访问你的服务器端的文件：
a.使用绝对路径：
比如将你的参数文件放在c:"yourconfig"yourconf.properties，
直接使用 new FileInputStream("yourconfig/yourconf.properties");
b.使用相对路径：
相对路径的根目录就是你的webapplication的根路径，即WEB-INF的上一级目录，将你的参数文件放

在yourwebapp"yourconfig"yourconf.properties，
这样使用：
new FileInputStream("./yourconfig/yourconf.properties");
这两种方式均可，自己选择。

(2).Tomcat

在类中输出System.getProperty("user.dir");显示的是%Tomcat_Home%/bin

(3).Resin

不是你的JSP放的相对路径,是JSP引擎执行这个JSP编译成SERVLET
的路径为根.比如用新建文件法测试File f = new File("a.htm");
这个a.htm在resin的安装目录下

(4).如何读相对路径哪？

在Java文件中getResource或getResourceAsStream均可

例：getClass().getResourceAsStream(filePath);//filePath可以是"/filename",这里的/代表web

发布根路径下WEB-INF/classes

默认使用该方法的路径是：WEB-INF/classes。已经在Tomcat中测试。

1. Pragmatic Programmer - An attitude, a style, a philosophy of approaching problems and their solutions. They think beyond the immediate problem, always trying to place it in its larger context, always trying to be aware of the bigger picture.
   
2. Take responsibility for everything they do. Don't sit idly by and watch their projects fall apart through neglect.
   One of the cornerstones of the pragmatic philosophy is the idea of taking responsibility for yourself and your actions. Don't be afraid to admit ignorance or error. Be honest about our shortcomings-our ignorance as well as our mistakes. Don't blame someone else or make up an excuse. Have a contingency plan. Provide Options, Don't Make Lame Excuses.
   
3. Learning is a continuous and ongoing process.
4. Don't Live with Broken Windows。
   Don't leave bad designs,wrong decisions, or poor code unrepaired. It's easy to slip into the mindset of "All the rest of this code is crap, I'll just follow suit." But if you find yourself on a team and a project where the code is pristinely beautiful-clean written, well designed, and elegant, you will likely take extra special care not to mess it up. Everyone dont't want to be the first one to make a mess.
   

J Steven Perry, 首席顾问, Makoto Consulting Group, Inc.

2009 年 12 月 14 日

任 何企业应用程序都需要处理时间问题。应用程序需要知道当前的时间点和下一个时间点，有时它们还必须计算这两个时间点之间的路径。使用 JDK 完成这项任务将非常痛苦和繁琐。现在来看看 Joda Time，一个面向 Java™ 平台的易于使用的开源时间/日期库。正如您在本文中了解的那样，Joda-Time 轻松化解了处理日期和时间的痛苦和繁琐。

在编写企业应用程序时，我常常需要处理日期。并且在我的最新项目中 — 保险行业 — 纠正日期计算尤其重要。使用 java.util.Calendar 让我有些不安。如果您也曾使用这个类处理过日期/时间值，那么您就知道它使用起来有多麻烦。因此当我接触到 Joda-Time — 面向 Java 应用程序的日期/时间库的替代选择 — 我决定研究一下。其结果是：我很庆幸我这么做了。

Joda-Time 令时间和日期值变得易于管理、操作和理解。事实上，易于使用是 Joda 的主要设计目标。其他目标包括可扩展性、完整的特性集以及对多种日历系统的支持。并且 Joda 与 JDK 是百分之百可互操作的，因此您无需替换所有 Java 代码，只需要替换执行日期/时间计算的那部分代码。

Joda 大型项目 Joda 实际上是涵盖众多用于 Java 语言的替代 API 的大型项目，因此从技术上讲，使用 Joda 和 Joda-Time 名称表示相同的意思是一种误称。但在撰写本文之际，Joda-Time API 目前似乎是唯一处于活跃开发状态下的 Joda API。考虑到 Joda 大型项目的当前状态，我想将 Joda-Time 简称为 Joda 应该没什么问题。

本文将介绍并展示如何使用它。我将介绍以下主题：

• 日期/时间替代库简介
• Joda 的关键概念
• 创建 Joda-Time 对象
• 以 Joda 的方式操作时间 style
• 以 Joda 的方式格式化时间

您可以 下载 演示这些概念的样例应用程序的源代码。

Joda 简介

为什么要使用 Joda？考虑创建一个用时间表示的某个随意的时刻 — 比如，2000 年 1 月 1 日 0 时 0 分。我如何创建一个用时间表示这个瞬间的 JDK 对象？使用 java.util.Date？事实上这是行不通的，因为自 JDK 1.1 之后的每个 Java 版本的 Javadoc 都声明应当使用 java.util.Calendar。Date 中不赞成使用的构造函数的数量严重限制了您创建此类对象的途径。

然而，Date 确实有一个构造函数，您可以用来创建用时间表示某个瞬间的对象（除 “现在” 以外）。该方法使用距离 1970 年 1 月 1 日子时格林威治标准时间（也称为 epoch）以来的毫秒数作为一个参数，对时区进行校正。考虑到 Y2K 对软件开发企业的重要性，您可能会认为我已经记住了这个值 — 但是我没有。Date 也不过如此。

那么 Calendar 又如何呢？我将使用下面的方式创建必需的实例：

Calendar calendar = Calendar.getInstance();

            calendar.set(2000, Calendar.JANUARY, 1, 0, 0, 0);

            

使用 Joda，代码应该类似如下所示：

DateTime dateTime = new DateTime(2000, 1, 1, 0, 0, 0, 0);

            

这一行简单代码没有太大的区别。但是现在我将使问题稍微复杂化。假设我希望在这个日期上加上 90 天并输出结果。使用 JDK，我需要使用清单 1 中的代码：

				

            Calendar calendar = Calendar.getInstance();

            calendar.set(2000, Calendar.JANUARY, 1, 0, 0, 0);

            SimpleDateFormat sdf =

            new SimpleDateFormat("E MM/dd/yyyy HH:mm:ss.SSS");

            calendar.add(Calendar.DAY_OF_MONTH, 90);

            System.out.println(sdf.format(calendar.getTime()));

            

使用 Joda，代码如清单 2 所示：

				

            DateTime dateTime = new DateTime(2000, 1, 1, 0, 0, 0, 0);

            System.out.println(dateTime.plusDays(90).toString("E MM/dd/yyyy HH:mm:ss.SSS");

            

两者之间的差距拉大了（Joda 用了两行代码，JDK 则是 5 行代码）。

现在假设我希望输出这样一个日期：距离 Y2K 45 天之后的某天在下一个月的当前周的最后一天的日期。坦白地说，我甚至不想使用 Calendar 处理这个问题。使用 JDK 实在太痛苦了，即使是简单的日期计算，比如上面这个计算。正是多年前的这样一个时刻，我第一次领略到 Joda-Time 的强大。使用 Joda，用于计算的代码如清单 3 所示：

				

            DateTime dateTime = new DateTime(2000, 1, 1, 0, 0, 0, 0);

            System.out.println(dateTime.plusDays(45).plusMonths(1).dayOfWeek()

            .withMaximumValue().toString("E MM/dd/yyyy HH:mm:ss.SSS");

            

清单 3 的输出为：

Sun 03/19/2000 00:00:00.000

如果您正在寻找一种易于使用的方式替代 JDK 日期处理，那么您真的应该考虑 Joda。如果不是这样的话，那么继续痛苦地使用 Calendar 完成所有日期计算吧。当您做到这一点后，您完全可以做到使用几把剪刀修建草坪并使用一把旧牙刷清洗您的汽车。

Joda 和 JDK 互操作性

JDK Calendar 类缺乏可用性，这一点很快就能体会到，而 Joda 弥补了这一不足。Joda 的设计者还做出了一个决定，我认为这是它取得成功的构建：JDK 互操作性。Joda 的类能够生成（但是，正如您将看到的一样，有时会采用一种比较迂回的方式）java.util.Date 的实例（和 Calendar）。这使您能够保留现有的依赖 JDK 的代码，但是又能够使用 Joda 处理复杂的日期/时间计算。

例如，完成 清单 3 中的计算后。我只需要做出如清单 4 所示的更改就可以返回到 JDK 中：

				

            Calendar calendar = Calendar.getInstance();

            DateTime dateTime = new DateTime(2000, 1, 1, 0, 0, 0, 0);

            System.out.println(dateTime.plusDays(45).plusMonths(1).dayOfWeek()

            .withMaximumValue().toString("E MM/dd/yyyy HH:mm:ss.SSS");

            calendar.setTime(dateTime.toDate());

            

就是这么简单。我完成了计算，但是可以继续在 JDK 对象中处理结果。这是 Joda 的一个非常棒的特性。

回页首

Joda 的关键日期/时间概念

Joda 使用以下概念，它们可以应用到任何日期/时间库：

• 不可变性（Immutability）
• 瞬间性（Instant）
• 局部性（Partial）
• 年表（Chronology）
• 时区（Time zone）

我将针对 Joda 依次讨论每一个概念。

不可变性

我 在本文讨论的 Joda 类具有不可变性，因此它们的实例无法被修改。（不可变类的一个优点就是它们是线程安全的）。我将向您展示的用于处理日期计算的 API 方法全部返回一个对应 Joda 类的新实例，同时保持原始实例不变。当您通过一个 API 方法操作 Joda 类时，您必须捕捉该方法的返回值，因为您正在处理的实例不能被修改。您可能对这种模式很熟悉；比如，这正是 java.lang.String 的各种操作方法的工作方式。

瞬间性

Instant 表示时间上的某个精确的时刻，使用从 epoch 开始计算的毫秒表示。这一定义与 JDK 相同，这就是为什么任何 Joda Instant 子类都可以与 JDK Date 和 Calendar 类兼容的原因。

更通用一点的定义是：一个瞬间 就是指时间线上只出现一次且唯一的一个时间点，并且这种日期结构只能以一种有意义的方式出现一次。

局部性

一个局部时间，正如我将在本文中将其称为局部时间片段一样，它指的是时间的一部分片段。瞬间性指定了与 epoch 相对的时间上的一个精确时刻，与此相反，局部时间片段指的是在时间上可以来回 “移动” 的一个时刻，这样它便可以应用于多个实例。比如，6 月 2 日 可以应用于任意一年的 6 月份（使用 Gregorian 日历）的第二天的任意瞬间。同样，11:06 p.m. 可以应用于任意一年的任意一天，并且每天只能使用一次。即使它们没有指定一个时间上的精确时刻，局部时间片段仍然是有用的。

我喜欢将局部时间片段看作一个重复周期中的一点，这样的话，如果我正在考虑的日期构建可以以一种有意义的方式出现多次（即重复的），那么它就是一个局部时间。

年表

Joda 本质 — 以及其设计核心 — 的关键就是年表（它的含义由一个同名抽象类捕捉）。从根本上讲，年表是一种日历系统 — 一种计算时间的特殊方式 — 并且是一种在其中执行日历算法的框架。受 Joda 支持的年表的例子包括：

• ISO（默认）
• Coptic
• Julian
• Islamic

Joda-Time 1.6 支持 8 种年表，每一种都可以作为特定日历系统的计算引擎。

时区

时 区是值一个相对于英国格林威治的地理位置，用于计算时间。要了解事件发生的精确时间，还必须知道发生此事件的位置。任何严格的时间计算都必须涉及时区（或 相对于 GMT），除非在同一个时区内发生了相对时间计算（即时这样时区也很重要，如果事件对于位于另一个时区的各方存在利益关系的话）。

DateTimeZone 是 Joda 库用于封装位置概念的类。许多日期和时间计算都可以在不涉及时区的情况下完成，但是仍然需要了解 DateTimeZone 如何影响 Joda 的操作。默认时间，即从运行代码的机器的系统时钟检索到的时间，在大部分情况下被使用。

回页首

创建 Joda-Time 对象

现在，我将展示在采用该库时会经常遇到的一些 Joda 类，并展示如何创建这些类的实例。

可变的 Joda 类 我并不是可变实用类的粉丝；我只是认为它们的用例并不适合广泛使用。但是如果您认为您的确需要使用可变 Joda 类的话，本节的内容应当会对您的项目有帮助。Readable 和 ReadWritable API 之间的唯一区别在于 ReadWritable 类能够改变封装的日期/时间值，因此我在这里将不再介绍这一点。

本节中介绍的所有实现都具有若干构造函数，允许您初始化封装的日期/时间。它们可以分为 4 个类别：

• 使用系统时间。
• 使用多个字段指定一个瞬间时刻（或局部时间片段），达到这个特定实现所能支持的最细粒度的精确度。
• 指定一个瞬间时刻（或局部时间片段），以毫秒为单位。
• 使用另一个对象（例如，java.util.Date，或者是另一个 Joda 对象）。

我将在第一个类中介绍这些构造函数： DateTime。当您使用其他 Joda 类的相应构造函数时，也可以使用这里介绍的内容。

重载方法 如果您创建了一个 DateTime 的实例，并且没有提供 Chronology 或 DateTimeZone，Joda 将使用 ISOChronology（默认）和 DateTimeZone（来自系统设置）。然而，Joda ReadableInstant 子类的所有构造函数都包含一个超载方法，该方法以一个 Chronology 或 DateTimeZone 为参数。本文附带的应用程序的的样例代码展示了如何使用这些超载方法（参见 下载）。我在这里不会再详细介绍它们，因为这些方法使用起来非常简单。然而，我建议您试着使用一下这个样例应用程序，看看编写您的应用程序代码有多么简单，这样您就可以随意地在 Joda 的 Chronology 和 DateTimeZone 之间切换，同时不会影响到代码的其余部分。

ReadableInstant

Joda 通过 ReadableInstant 类实现了瞬间性这一概念。表示时间上的不可变瞬间的 Joda 类都属于这个类的子类。（将这个类命名为 ReadOnlyInstant 可能更好，我认为这才是设计者需要传达的意思）。换句话说，ReadableInstant 表示时间上的某一个不可修改的瞬间）。其中的两个子类分别为 DateTime 和 DateMidnight：

• DateTime：这是最常用的一个类。它以毫秒级的精度封装时间上的某个瞬间时刻。DateTime 始终与 DateTimeZone 相关，如果您不指定它的话，它将被默认设置为运行代码的机器所在的时区。

  可以使用多种方式构建 DateTime 对象。这个构造函数使用系统时间：

  DateTime dateTime = new DateTime();

  
  一般来讲，我会尽量避免使用系统时钟来初始化应用程序的实际，而是倾向于外部化设置应用程序代码使用的系统时间。样例应用程序执行以下代码：

  DateTime dateTime = SystemFactory.getClock().getDateTime();

  
  这使得使用不同日期/时间测试我的代码变得更加简单：我不需要修改代码来在应用程序中运行不同的日期场景，因为时间是在 SystemClock 实现的内部设置的，而不是在应用程序的内部。（我可以修改系统时间，但是那实在太痛苦了！）

  下面的代码使用一些字段值构建了一个 DateTime 对象：

  DateTime dateTime = new DateTime( 2000, //year 1, // month 1, // day 0, // hour (midnight is zero) 0, // minute 0, // second 0 // milliseconds );

  
  

  正如您所见，Joda 可以使您精确地控制创建 DateTime 对象的方式，该对象表示时间上的某个特定的瞬间。每一个 Joda 类都有一个与此类似的构造函数，您在此构造函数中指定 Joda 类可以包含的所有字段。您可以用它快速了解特定类在哪一种粒度级别上操作。

  下一个构造函数将指定从 epoch 到某个时刻所经过的毫秒数。它根据 JDK Date 对象的毫秒值创建一个 DateTime 对象，其时间精度用毫秒表示，因为 epoch 与 Joda 是相同的：

  java.util.Date jdkDate = obtainDateSomehow(); long timeInMillis = jdkDate.getTime(); DateTime dateTime = new DateTime(timeInMillis);

  
  

  并且这个例子与前例类似，唯一不同之处是我在这里将 Date 对象直接传递给构造函数：

  java.util.Date jdkDate = obtainDateSomehow(); dateTime = new DateTime(jdkDate);

  
  

  Joda 支持使用许多其他对象作为构造函数的参数，用于创建 DateTime，如清单 5 所示：

  
  
  清单 5. 直接将不同对象传递给 DateTime 的构造函数
  

  // Use a Calendar java.util.Calendar calendar = obtainCalendarSomehow(); dateTime = new DateTime(calendar); // Use another Joda DateTime DateTime anotherDateTime = obtainDateTimeSomehow(); dateTime = new DateTime(anotherDateTime); // Use a String (must be formatted properly) String timeString = "2006-01-26T13:30:00-06:00"; dateTime = new DateTime(timeString); timeString = "2006-01-26"; dateTime = new DateTime(timeString);

  
  

  注意，如果您准备使用 String（必须经过解析），您必须对其进行精确地格式化。参考 Javadoc，获得有关 Joda 的 ISODateTimeFormat 类的更多信息（参见 参考资料）。

• DateMidnight：这个类封装某个时区（通常为默认时区）在特定年/月/日的午夜时分的时刻。它基本上类似于 DateTime，不同之处在于时间部分总是为与该对象关联的特定 DateTimeZone 时区的午夜时分。

您将在本文看到的其他类都遵循与 ReadableInstant 类相同的模式（Joda Javadoc 将显示这些内容），因此为了节省篇幅，我将不会在以下小节介绍这些内容。

ReadablePartial

应用程序所需处理的日期问题并不全部都与时间上的某个完整时刻有关，因此您可以处理一个局部时刻。例如，有时您比较关心年/月/日，或者一天中的时间，甚至是一周中的某天。Joda 设计者使用 ReadablePartial 接口捕捉这种表示局部时间的概念，这是一个不可变的局部时间片段。用于处理这种时间片段的两个有用类分别为 LocalDate 和 LocalTime：

• LocalDate：该类封装了一个年/月/日的组合。当地理位置（即时区）变得不重要时，使用它存储日期将非常方便。例如，某个特定对象的出生日期 可能为 1999 年 4 月 16 日，但是从技术角度来看，在保存所有业务值的同时不会了解有关此日期的任何其他信息（比如这是一周中的星期几，或者这个人出生地所在的时区）。在这种情况下，应当使用 LocalDate。

  样例应用程序使用 SystemClock 来获取被初始化为系统时间的 LocalDate 的实例：

  LocalDate localDate = SystemFactory.getClock().getLocalDate();

  
  

  也可以通过显式地提供所含的每个字段的值来创建 LocalDate：

  LocalDate localDate = new LocalDate(2009, 9, 6);// September 6, 2009

  
  

  LocalDate 替代了在早期 Joda 版本中使用的 YearMonthDay。

• LocalTime： 这个类封装一天中的某个时间，当地理位置不重要的情况下，可以使用这个类来只存储一天当中的某个时间。例如，晚上 11:52 可能是一天当中的一个重要时刻（比如，一个 cron 任务将启动，它将备份文件系统的某个部分），但是这个时间并没有特定于某一天，因此我不需要了解有关这一时刻的其他信息。

  样例应用程序使用 SystemClock 获取被初始化为系统时间的 LocalTime 的一个实例：

  LocalTime localTime = SystemFactory.getClock().getLocalTime();

  
  

  也可以通过显式地提供所含的每个字段的值来创建 LocalTime：

  LocalTime localTime = new LocalTime(13, 30, 26, 0);// 1:30:26PM

  
  

时间跨度

了解特定的时刻或是某个局部时间片段将非常有用，但是如果能够表达一段时间跨度的话，通常也很有用。Joda 提供了三个类来简化这个过程。您可以选择用于表示不同跨度的类：

• Duration：这个类表示一个绝对的精确跨度，使用毫秒为单位。这个类提供的方法可以用于通过标准的数学转换（比如 1 分钟 = 60 秒，1 天 = 24 小时），将时间跨度转换为标准单位（比如秒、分和小时）。

  您只在以下情况使用 Duration 的实例：您希望转换一个时间跨度，但是您并不关心这个时间跨度在何时发生，或者使用毫秒处理时间跨度比较方便。

• Period：这个类表示与 Duration 相同的概念，但是以人们比较熟悉的单位表示，比如年、月、周。

  您可以在以下情况使用 Period：您并不关心这段时期必须在何时发生，或者您更关心检索单个字段的能力，这些字段描述由 Period 封装的时间跨度。

• Interval：这个类表示一个特定的时间跨度，将使用一个明确的时刻界定这段时间跨度的范围。Interval 为半开 区间，这表示由 Interval 封装的时间跨度包括这段时间的起始时刻，但是不包含结束时刻。

  可以在以下情况使用 Interval：需要表示在时间连续区间中以特定的点开始和结束的一段时间跨度。

回页首

以 Joda 的方式处理时间

现在，您已经了解了如何创建一些非常有用的 Joda 类，我将向您展示如何使用它们执行日期计算。接着您将了解到 Joda 如何轻松地与 JDK 进行互操作。

日期计算

如果您只是需要对日期/时间信息使用占位符，那么 JDK 完全可以胜任，但是它在日期/时间计算方面的表现十分糟糕，而这正是 Joda 的长处。我将向您展示一些简单的例子。

假设在当前的系统日期下，我希望计算上一个月的最后一天。对于这个例子，我并不关心一天中的时间，因为我只需要获得年/月/日，如清单 6 所示：

				

            LocalDate now = SystemFactory.getClock().getLocalDate();

            LocalDate lastDayOfPreviousMonth ="

            now.minusMonths(1).dayOfMonth().withMaximumValue(); 

            

您可能对清单 6 中的 dayOfMonth() 调用感兴趣。这在 Joda 中被称为属性（property）。它相当于 Java 对象的属性。属性是根据所表示的常见结构命名的，并且它被用于访问这个结构，用于完成计算目的。属性是实现 Joda 计算威力的关键。您目前所见到的所有 4 个 Joda 类都具有这样的属性。一些例子包括：

• yearOfCentury
• dayOfYear
• monthOfYear
• dayOfMonth
• dayOfWeek

我将详细介绍清单 6 中的示例，以向您展示整个计算过程。首先，我从当前月份减去一个月，得到 “上一个月”。接着，我要求获得 dayOfMonth 的最大值，它使我得到这个月的最后一天。注意，这些调用被连接到一起（注意 Joda ReadableInstant 子类是不可变的），这样您只需要捕捉调用链中最后一个方法的结果，从而获得整个计算的结果。

当计算的中间结果对我不重要时，我经常会使用这种计算模式。（我以相同的方式使用 JDK 的 BigDecimal）。假设您希望获得任何一年中的第 11 月的第一个星期二的日期，而这天必须是在这个月的第一个星期一之后。清单 7 展示了如何完成这个计算：

				

            LocalDate now = SystemFactory.getClock().getLocalDate();

            LocalDate electionDate = now.monthOfYear()

            .setCopy(11)        // November

            .dayOfMonth()       // Access Day Of Month Property

            .withMinimumValue() // Get its minimum value

            .plusDays(6)        // Add 6 days

            .dayOfWeek()        // Access Day Of Week Property

            .setCopy("Monday")  // Set to Monday (it will round down)

            .plusDays(1);       // Gives us Tuesday

            

清单 7 的注释帮助您了解代码如何获得结果。.setCopy("Monday") 是整个计算的关键。不管中间 LocalDate 值是多少，将其 dayOfWeek 属性设置为 Monday 总是能够四舍五入，这样的话，在每月的开始再加上 6 天就能够让您得到第一个星期一。再加上一天就得到第一个星期二。Joda 使得执行此类计算变得非常容易。

下面是其他一些因为使用 Joda 而变得超级简单的计算：

以下代码计算从现在开始经过两个星期之后的日期：

DateTime now = SystemFactory.getClock().getDateTime();

            DateTime then = now.plusWeeks(2);

            

您可以以这种方式计算从明天起 90 天以后的日期：

DateTime now = SystemFactory.getClock().getDateTime();

            DateTime tomorrow = now.plusDays(1);

            DateTime then = tomorrow.plusDays(90);

            

（是的，我也可以向 now 加 91 天，那又如何呢？）

下面是计算从现在起 156 秒之后的时间：

DateTime now = SystemFactory.getClock().getDateTime();

            DateTime then = now.plusSeconds(156);

            

下面的代码将计算五年后的第二个月的最后一天：

DateTime now = SystemFactory.getClock().getDateTime();

            DateTime then = now.minusYears(5) // five years ago

            .monthOfYear()     // get monthOfYear property

            .setCopy(2)        // set it to February

            .dayOfMonth()      // get dayOfMonth property

            .withMaximumValue();// the last day of the month

            

这样的例子实在太多了，我向您已经知道了如何计算。尝试操作一下样例应用程序，亲自体验一下使用 Joda 计算任何日期是多么有趣。

JDK 互操作性

我的许多代码都使用了 JDK Date 和 Calendar 类。但是幸亏有 Joda，我可以执行任何必要的日期算法，然后再转换回 JDK 类。这将两者的优点集中到一起。您在本文中看到的所有 Joda 类都可以从 JDK Calendar 或 Date 创建，正如您在 创建 Joda-Time 对象 中看到的那样。出于同样的原因，可以从您所见过的任何 Joda 类创建 JDK Calendar 或 Date。

清单 8 展示了从 Joda ReadableInstant 子类转换为 JDK 类有多么简单：

				

            DateTime dateTime = SystemFactory.getClock().getDateTime();

            Calendar calendar = dateTime.toCalendar(Locale.getDefault());

            Date date = dateTime.toDate();

            DateMidnight dateMidnight = SystemFactory.getClock()

            .getDateMidnight();

            date = dateMidnight.toDate();

            

对于 ReadablePartial 子类，您还需要经过额外一步，如清单 9 所示：

				

            LocalDate localDate = SystemFactory.getClock().getLocalDate();

            Date date = localDate.toDateMidnight().toDate();

            

要创建 Date 对象，它表示从清单 9 所示的 SystemClock 中获得的 LocalDate，您必须首先将它转换为一个 DateMidnight 对象，然后只需要将 DateMidnight 对象作为 Date。（当然，产生的 Date 对象将把它自己的时间部分设置为午夜时刻）。

JDK 互操作性被内置到 Joda API 中，因此您无需全部替换自己的接口，如果它们被绑定到 JDK 的话。比如，您可以使用 Joda 完成复杂的部分，然后使用 JDK 处理接口。

回页首

以 Joda 方式格式化时间

使用 JDK 格式化日期以实现打印是完全可以的，但是我始终认为它应该更简单一些。这是 Joda 设计者进行了改进的另一个特性。要格式化一个 Joda 对象，调用它的 toString() 方法，并且如果您愿意的话，传递一个标准的 ISO-8601 或一个 JDK 兼容的控制字符串，以告诉 JDK 如何执行格式化。不需要创建单独的 SimpleDateFormat 对象（但是 Joda 的确为那些喜欢自找麻烦的人提供了一个 DateTimeFormatter 类）。调用 Joda 对象的 toString() 方法，仅此而已。我将展示一些例子。

清单 10 使用了 ISODateTimeFormat 的静态方法：

				

            DateTime dateTime = SystemFactory.getClock().getDateTime();

            dateTime.toString(ISODateTimeFormat.basicDateTime());

            dateTime.toString(ISODateTimeFormat.basicDateTimeNoMillis());

            dateTime.toString(ISODateTimeFormat.basicOrdinalDateTime());

            dateTime.toString(ISODateTimeFormat.basicWeekDateTime());

            

清单 10 中的四个 toString() 调用分别创建了以下内容：

20090906T080000.000-0500

            20090906T080000-0500

            2009249T080000.000-0500

            2009W367T080000.000-0500

            

您也可以传递与 SimpleDateFormat JDK 兼容的格式字符串，如清单 11 所示：

				

            DateTime dateTime = SystemFactory.getClock().getDateTime();

            dateTime.toString("MM/dd/yyyy hh:mm:ss.SSSa");

            dateTime.toString("dd-MM-yyyy HH:mm:ss");

            dateTime.toString("EEEE dd MMMM, yyyy HH:mm:ssa");

            dateTime.toString("MM/dd/yyyy HH:mm ZZZZ");

            dateTime.toString("MM/dd/yyyy HH:mm Z");

            

            09/06/2009 02:30:00.000PM

            06-Sep-2009 14:30:00

            Sunday 06 September, 2009 14:30:00PM

            09/06/2009 14:30 America/Chicago

            09/06/2009 14:30 -0500

            

查看 Javadoc 中有关 joda.time.format.DateTimeFormat 的内容，获得与 JDK SimpleDateFormat 兼容的格式字符串的更多信息，并且可以将其传递给 Joda 对象的 toString() 方法。

回页首

结束语

谈 到日期处理，Joda 是一种令人惊奇的高效工具。无论您是计算日期、打印日期，或是解析日期，Joda 都将是工具箱中的便捷工具。在本文中，我首先介绍了 Joda，它可以作为 JDK 日期/时间库的替代选择。然后介绍了一些 Joda 概念，以及如何使用 Joda 执行日期计算和格式化。

Joda-Time 衍生了一些相关的项目，您可能会发现这些项目很有用。现在出现了一个针对 Grails Web 开发框架的 Joda-Time 插件。joda-time-jpox 项目的目标就是添加一些必需的映射，以使用 DataNucleus 持久化引擎持久化 Joda-Time 对象。并且，一个针对 Google Web Toolkit（也称为 Goda-Time）的 Joda-Time 实现目前正在开发当中，但是在撰写本文之际因为许可问题而被暂停。访问 参考资料 获得更多信息。

回页首

下载

	关于下载方法的信息

参考资料

• Joda：在 SourceForge 中访问 Joda 项目，并查阅 Javadoc 获得有关 Joda-Time 库的内容。
  
  
• Joda-Time Plugin for Grails：了解面向 Grails 的 Joda-Time 插件。
  
  
• joda-time-jpox：了解有关 joda-time-jpox 项目的更多内容。
  
  
• Goda-Time：关注针对 Google Web Toolkit 的 Joda-Time 移植项目。
  
  
• 技术书店：浏览有关这些主题和其他技术主题的图书。
  
  
• developerWorks Java 技术专区：提供了数百篇有关 Java 编程各个方面的文章。
  
  

• Joda-Time：下载 Joda-Time 库。
  
  

• Joda-Time 邮件列表：订阅 Joda-Time 邮件列表或查看列表归档。
  
  
• 加入 My developerWorks 社区。

关于作者

		J Steven Perry 是一名软件开发人员、架构师和全能 Java 专家，他从 1991 年起就从事专业的软件开发。他的专业兴趣包括 JVM 的内部工作原理和 UML 建模，以及介于两者之间的所有内容。Steve 编写了从技术文档到 Java 代码等各种内容，并且对教学和培训也充满了热情。Steve 是 Java Management Extensions（O’Reilly）的作者，Java Enterprise Best Practices（O’Reilly）的合著者，并撰写了有关软件开发主题和 O'Reilly ShortCut: Log4J 的杂志文章。

1. 单方法接口：只含有一个方法，做特定的事情。例子：Runnable接口的run（）方法
2. 标记接口：没有任何方法和属性，不对实现他的类有任何语义上的要求，仅仅表明实现他的类属于特定的类型。例子：java.io.Serializable/java.rmi.Remote接口
3. 常量接口：在接口中声明一些常量，实现他的类就可以调用这些常量，不过不推荐使用。

UML中几种类间关系：继承、实现、依赖、关联、聚合、组合的联系与区别

继承

指的是一个类（称为子类、子接口）继承另外的一个类（称为父类、父接口）的功能，并可以增加它自己的新功能的能力，继承是类与类或者接口与接口之间最常见的关系；在Java中此类关系通过关键字extends明确标识，在设计时一般没有争议性；

实现

指的是一个class类实现interface接口（可以是多个）的功能；实现是类与接口之间最常见的关系；在Java中此类关系通过关键字implements明确标识，在设计时一般没有争议性；

依赖

可以简单的理解，就是一个类A使用到了另一个类B，而这种使用关系是具有偶然性的、、临时性的、非常弱的，但是B类的变化会影响到A；比如某人要过河，需要借用一条船，此时人与船之间的关系就是依赖；表现在代码层面，为类B作为参数被类A在某个method方法中使用；

关联

他体现的是两个类、或者类与接口之间语义级别的一种强依赖关系，比如我和我的朋友；这种关系比依赖更强、不存在依赖关系的偶然性、关系也不是临时性 的，一般是长期性的，而且双方的关系一般是平等的、关联可以是单向、双向的；表现在代码层面，为被关联类B以类属性的形式出现在关联类A中，也可能是关联 类A引用了一个类型为被关联类B的全局变量；

聚合

聚合是关联关系的一种特例，他体现的是整体与部分、拥有的关系，即has-a的关系，此时整体与部分之间是可分离的，他们可以具有各自的生命周期， 部分可以属于多个整体对象，也可以为多个整体对象共享；比如计算机与CPU、公司与员工的关系等；表现在代码层面，和关联关系是一致的，只能从语义级别来 区分；

组合

组合也是关联关系的一种特例，他体现的是一种contains-a的关系，这种关系比聚合更强，也称为强聚合；他同样体现整体与部分间的关系，但此 时整体与部分是不可分的，整体的生命周期结束也就意味着部分的生命周期结束；比如你和你的大脑；表现在代码层面，和关联关系是一致的，只能从语义级别来区 分；

对于继承、实现这两种关系没多少疑问，他们体现的是一种类与类、或者类与接口间的纵向关系；其他的四者关系则体现的是类与类、或者类与接口间的引 用、横向关系，是比较难区分的，有很多事物间的关系要想准备定位是很难的，前面也提到，这几种关系都是语义级别的，所以从代码层面并不能完全区分各种关 系；但总的来说，后几种关系所表现的强弱程度依次为：组合>聚合>关联>依赖；

在 水木上看到一篇分析DCL（双检测锁定-Double Checked Lock）安全性的文章。记得以前也讨论过这个问题，但是为什么DCL也存在隐患，至今没弄明白，这篇分析做了比较详尽的解释，概括起来原因有两点：一是 因为编译器或者处理器并不是严格按照程序顺序进行指令调度。二是java中同步机制的存在。

原文来自：

发信人: wyxzellux (I still believe...), 信区: Java
标  题: Singleton模式与双检测锁定(DCL)
发信站: 水木社区 (Mon Apr  7 23:42:14 2008), 站内

看OOP教材时，提到了一个双检测锁定(Double-Checked Lock, DCL)的问题，但是书上没有多介绍，只是说这是一个和底层内存机制有关的漏洞。查阅了下相关资料，对这个问题大致有了点了解。
从头开始说吧。
在多线程的情况下Singleton模式会遇到不少问题，一个简单的例子

   1:  class Singleton {      
   2:      private static Singleton instance = null;      
   3:        
   4:      public static Singleton instance() {      
   5:          if (instance == null) {      
   6:              instance = new Singleton();      
   7:          }      
   8:          return instance;    
   9:      }    
   10:  }
  
假 设这样一个场景，有两个线程调用Singleton.instance()，首先线程一判断instance是否等于null，判断完后一瞬间虚拟机把线 程二调度为运行线程，线程二再次判断instance是否为null，然后创建一个Singleton实例，线程二的时间片用完后，线程一被唤醒，接下来 它执行的代码依然是instance = new Singleton();
两次调用返回了不同的对象，出现问题了。

最简单的方法自然是在类被载入时就初始化这个对象：private static Singleton instance = new Singleton();

JLS(Java Language Specification)中规定了一个类只会被初始化一次，所以这样做肯定是没问题的。

但是如果要实现延迟初始化(Lazy initialization)，比如这个实例初始化时的参数要在运行期才能确定，应该怎么做呢？

依然有最简单的方法：使用synchronized关键字修饰初始化方法：

    public synchronized static Singleton instance() {        
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
    
这里有一个性能问题：多个线程同时访问这个方法时，会因为同步而导致每次只有一个线程运行，影响程序性能。而事实上初始化完毕后只需要简单的返回instance的引用就行了。

DCL是一个“看似”有效的解决方法，先把对应代码放上来吧：

    1 :   class Singleton {  
    2 :       private static Singleton instance = null ;  
    3 :      
    4 :       public static Singleton instance() {  
    5 :           if (instance == null ) {
    6 :               synchronized (this) {  
    7 :                   if (instance == null)
    8 :                      instance = new Singleton();
    9 :              }
    10 :          }
    11 :          return instance;
    12 :      }
    13 :  }

用JavaWorld上对应文章的标题来评论这种做法就是smart, but broken。来看原因：

Java 编译器为了提高程序性能会进行指令调度，CPU在执行指令时同样出于性能会乱序执行（至少现在用的大多数通用处理器都是out-of-order的），另 外cache的存在也会改变数据回写内存时的顺序[2]。JMM(Java Memory Model, 见[1])指出所有的这些优化都是允许的，只要运行结果和严格按顺序执行所得的结果一样即可。

Java假设每个线程都跑在自己的处理器 上，享有自己的内存，和共享的主存交互。注意即使在单核上这种模型也是有意义的，考虑到cache和寄存器会保存部分临时变量。理论上每个线程修改自己的 内存后，必须立即更新对应的主存内容。但是Java设计师们认为这种约束会影响程序性能，他们试着创造了一套让程序跑得更快、但又保证线程之间的交互与预 期一致的内存模型。

synchronized关键字便是其中一把利器。事实上，synchronized块的实现和Linux中的信号量 (semaphore)还是有区别的，前者过程中锁的获得和释放都会都会引发一次Memory Barrier来强制线程本地内存和主存之间的同步。通过这个机制，Java中的同步机制保证了synchronized块中指令的原子性 (atomic)。

好了，回过头来看DCL问题。看起来访问一个未同步的instance字段不会产生什么问题，我们再次来假设一个场景：

线程一进入同步块，执行instance = new Singleton(); 线程二刚开始执行getResource();

按照顺序的话，接下来应该执行的步骤是 1) 分配新的Singleton对象的内存 2) 调用Singleton的构造器，初始化成员字段 3) instance被赋为指向新的对象的引用。

前 面说过，编译器或处理器都为了提高性能都有可能进行指令的乱序执行，线程一的真正执行步骤可能是1) 分配内存 2) instance指向新对象 3) 初始化新实例。如果线程二在2完成后3执行前被唤醒，它看到了一个不为null的instance，跳出方法体走了，带着一个还没初始化的 Singleton对象。

错误发生的一种情形就是这样，关于更详细的编译器指令调度导致的问题，可以参看这个网页 [4]。

[3] 中提供了一个编译器指令调度的证据

instance = new Singleton(); 这条命令在Symantec JIT中被编译成

0206106A   mov         eax,0F97E78h
0206106F   call        01F6B210                  ; 分配空间
02061074   mov         dword ptr [ebp],eax       ; EBP中保存了instance的地址

02061077   mov         ecx,dword ptr [eax]       ; 解引用，获得新的指针地址

02061079   mov         dword ptr [ecx],100h      ; 接下来四行是inline后的构造器
0206107F   mov         dword ptr [ecx+4],200h    
02061086   mov         dword ptr [ecx+8],400h
0206108D   mov         dword ptr [ecx+0Ch],0F84030h

可以看到，赋值完成在初始化之前，而这是JLS允许的。
 
另 一种情形是，假设线程一安稳地完成Singleton对象的初始化，退出了同步块，并同步了和本地内存和主存。线程二来了，看到一个非空的引用，拿走。注 意线程二没有执行一个Read Barrier，因为它根本就没进后面的同步块。所以很有可能此时它看到的数据是陈旧的。

还有很多人根据已知的几种提出了一个又一个fix的方法，但最终还是出现了更多的问题。可以参阅[3]中的介绍。

[5]中还说明了即使把instance字段声明为volatile还是无法避免错误的原因。

由此可见，安全的Singleton的构造一般只有两种方法，一是在类载入时就创建该实例，二是使用性能较差的synchronized方法。

(by ZelluX  http://www.blogjava.net/zellux )

参考资料：

[1] Java Language Specification, Second Edition, 第17章介绍了Java中线程和内存交互关系的具体细节。
[2] out-of-order与cache的介绍可以参阅Computer System, A Programmer's Perspective的第四、五章。
[3] The "Double-Checked Locking is Broken" Declaration, http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html
[4] Synchronization and the Java Memory Model, http://gee.cs.oswego.edu/dl/cpj/jmm.html
[5] Double-checked locking: Clever, but broken, http://www.javaworld.com/javaworld/jw-02-2001/jw-0209-double.html?page=1
[6] Holub on Patterns, Learning Design Patterns by Looking at Code

Since the default memory setting usually is around 64 or 128MB (256MB in Confluence 2.2 and later), you might have to adjust the settings to run a bigger Confluence instance with sufficient memory.

On this page:

Diagnosis and Common Causes

There are several reasons that out of memory exceptions can be thrown. Either the virtual machine Confluence is using has hit its allocated memory limit, the system on which Confluence is running has run out of physical and virtual memory, or Confluence is consuming too much memory. In the first case, you should modify the maximum heap size of the virtual machine, per the instructions in this document; in the second or third cases, the solution is to identify the culprit of the memory leak.

For help determining which memory settings to choose, consult Managing Application Server Memory Settings.

If you have not yet set your memory settings and your usage has increased, it's likely that you must set your memory, described below. If your usage patterns have not changed but you've added a plugin or done an upgrade, it's likely that there is a memory leak in a plugin.

1. If you're using the in-memory database (HSQLDB), migrate to an external database. The in-memory database can use a lot of memory.
2. If you are using XML backups, disable them and move to the Alternative Backup Strategy. The XML backup process can be a memory hog.

To troubleshoot potential memory leaks, enter Plugin Support Mode. Take thread dumps during normal operations and during an outage, and submit this information in a support ticket.

Determining the various causes of memory errors

There are different kinds of memory limits inside the Java Virtual Machine. Each limit can be configured independently. But you must first find out which limit you have reached.

java.lang.OutOfMemoryError: PermGen space

If you get the error message: java.lang.OutOfMemoryError: PermGen space this means that you have exceeded Java's default 64Mb block for loading class files. This can happen if many plugins are installed. You may want to increase the PermGen memory size to suit your needs.

In the following sample, the blue parameter shows how the PermGen Memory has been set to 192 megabytes. This value should be set depending on your memory requirements. 192m should be sufficient for Confluence even when many plugins are installed.

Note: The other parameters in this sample are just shown to give you some context, and are not part of this example.

java.lang.OutOfMemoryError

Heap space memory errors occur when the application has to deal with large amounts of data or users. These errors will contain only a java.lang.OutOfMemoryError, e.g. without the reference to PermGen space as above. You should try to increase the heap size to solve this problem. This requires configuring the Xmx and Xms parameters. In the following example, the maximum heap size is set to 1024 megabytes. This should be enough for small to medium deployments.

Note: The other parameters are only shown to give you context and are not part of this example.

Deployments with high usage patterns may require additional memory. For high-usage deployments, it is recommended to set both Xms and Xmx as the same value (eg. -Xms1024m -Xmx1024m), _provided the memory is available_. On the other hand, adding too much memory can also cause problems (see below), so you should increment memory carefully, for example in increments of 128 megabytes.

OutOfMemoryError: unable to create new native thread

This error occurs when the operating system is unable to create new threads. This is due to the JVM Heap taking up the available RAM.

Big heaps take away from the space that can be allocated for the stack of a new thread

For 32bit Linux generally the maximum heap size of the JVM cannot be greater than 2GB. Windows systems will typically split the available physical memory 50:50 as Application and Kernel/System space, so please do not allocate an amount exceeding or approaching that split.
The size of the stack per thread can also contribute to this problem. The stack size can reduce the number of threads that can be created.

To fix this problem, you should reduce the size of your JVM Heap and also the size of the stack per thread.
The stack size can be changed with the following (example) parameter:

"-Xss512k"

Please refer to this guide as a reference for JVM tuning.

OutOfMemoryError: GC overhead limit exceeded

This error indicates that the JVM took too long to free up memory during its GC process. This error can be thrown from the Serial, Parallel or Concurrent collectors. It often means that the Xmx value is too high - you might consider lowering it. See Garbage Collector Performance Issues for more details. For more severe and persistent performance issues relating to GC, it is recommended to change to a parallel collector, and to ensure that Confluence has access to the memory demanded by its users.

The parallel collector will throw an OutOfMemoryError if too much time is being spent in garbage collection: if more than 98% of the total time is spent in garbage collection and less than 2% of the heap is recovered, an OutOfMemoryError will be thrown. This feature is designed to prevent applications from running for an extended period of time while making little or no progress because the heap is too small. If necessary, this feature can be disabled by adding the option -XX:-UseGCOverheadLimit to the command line.

This kind of OutOfMemoryError can be caused if user requests drown the available resources in the JVM. When this occurs, performance will degrade aggressively. This will eventually require a restart or the application may recover.

OutOfMemoryError: Requested array size exceeds VM limit

This is a rare error and indicates that Confluence attempted to allocate an array that is larger than the Java heap size. More details regarding this error can be found here.
This is due to a known limitation of the JVM as documented here. We have a bug lodged against this, to better handle this exception in Confluence.

Setting the Memory Settings

How to set the heap or permanent generation memory depends on your distribution, platform, and how you start Confluence. Refer to Configuring System Properties.

If you're starting Confluence from a Windows Service, make sure you add the properties through the registry settings.

To verify if your settings have been picked up, check Displaying System Properties.

Other factors such as system load and allocating too much memory to your JVM Heap can also cause OutOfMemory Errors. For more information, you can refer to the JIRA documentation on Causes of OutOfMemoryErrors.

RELATED TOPICS

Managing Application Server Memory Settings
Installing the Confluence EAR-WAR Edition
FAQ Home
Tomcat JVM options and Modify the Default JVM Settings
Websphere Tuning JVM
Logging A Thread Dump

所以使用了Collections.copy()方法来进行拷贝，但是这样就接触到了此方法所报出的异常：

使用这位仁兄的方法，我这边一直报错说找不到此构造函数，估计是因为我使用了jdk6的原因，后来使用了替代方法，用apache的CollectionUtils：

作者： 周靖 译
http://www.zdnet.com.cn/developer/tech/story/0,3800067013,39139224-1,00.htm


在 某种意义上，可将Cocoon视为一个基于XML的内容管理系统，因其提供了一种机制来描述Web信息项目（内容）的结构和语义、这些项目的关系、它们如 何随着时间的推移而发生改变（逻辑）以及在请求时如何向用户呈现（它们的样式）。事实上，Cocoon项目作为Apache Web服务器项目的一部分，它的作用之一就是组织和控制Apache麾下众多项目的文档化过程。

作为对其真实用途的一个比喻，Cocoon（茧）这个名字具有深远的意义。它代表一种包裹结构，其中的某些东西将从幼虫阶段成长为美丽的蝴蝶，并准备展翅飞翔。但在Apache Cocoon的主页上， 没有对这个巧妙的比喻进行说明。相反，它只是对这个项目进行了准确的技术性解释：“Apache Cocoon是一个XML发布框架，它将XML和XSLT技术在服务器应用程序中的应用提升到一个新级别。Cocoon的宗旨是提升管道化SAX处理的性 能和扩展性，通过对内容、逻辑和样式的分离来营造一个灵活的环境。”

到底什么是Cocoon?

Cocoon最初的型态是一个简单的Java servlet，全部使用标准W3C组件：用文档对象模型（DOM）来解析文档，用XML来捕捉和格式化数据，用XSLT来转换数据和合并/操纵XML文 档，并用XSL来管理文档的表示以便通过Web传送。但人们很快就要求它为其他类型的内容提供服务（比如程序和文档），所以Cocoon逐渐发展成为一个 完整的、基于XML的发布框架及系统。

随着时间的推移，几个新的XML组件问世了，比如SAX。另外，XSL也逐渐细分为几个不同的组件，分别提供Transforms、 Formatting Objects和XPath功能。这些新标准直接促成了Cocoon 2在2002年的问世，它定义了一个标准的（而且仍在发展的）内容管理系统，并面向公众开放。

就目前来说，我们可采取几种不同的方式来描述Cocoon：一个XML发布框架，一个数据源聚合器以及一系列管道和组件的集合。

作为发布框架的Cocoon

Cocoon基于对SAX事件的管道式处理。Web应用程序如果围绕这个框架来构建，将获得较好的扩展性和性能。利用一个集中式的配置系统，你可以 方便地创建、部署和维护Web应用程序。Cocoon使用了一个缓存系统，所有组件都可根据需要进行动态配置。接收到用户请求后，会自动检查缓存，判断请 求的URI（统一资源标识符）是否存在。如果存在，就直接传递缓存的内容，不需要通过一个管道来处理它。

Cocoon作为数据源聚合器

Cocoon可作为一个抽象的引擎使用（通过一个Java servlet），它基于自定义的协议处理程序，能通过标准URI来访问外部数据源。Cocoon甚至能递归调用自身，使数据流能在多个管道化阶段同时处理，从而提高处理速度和效率。

管道和组件

Cocoon体系结构的核心设计思想是模块化和抽象处理。Cocoon管道在概念上和UNIX系统中使用的管道差不多，只是Cocoon管道中的所 有元素都是通过解析XML文档而创建的SAX事件。Cocoon识别3种类型的管道元素（组件），分别是生成器（generators）、转换器 （transformers）和序列化器（serializers）。其中，生成器使用一个请求的URI来生成SAX事件；转换器使用SAX事件并生成其 他SAX事件；序列化器使用SAX事件并生成一些响应。

Cocoon的用途

简单地说，Cocoon管道用于生成和递送内容。内容采用的是某种可识别的形式，由一个生成器和一个序列化器构成。在较典型的Cocoon管道中， 生成器之后可能紧接着一个或多个转换器链，而序列化器用于生成不同格式的输出。采取这种方式，同一个源文档可为Web浏览器生成HTML格式的内容，为 WAP设备生成WML格式的内容，为打印输出生成PDF格式的内容。

作为一个开发平台，Cocoon最吸引人的地方在于它提供了品种丰富的生成器、转换器和序列化器。人们为Cocoon 2项目开发和捐赠了许多这样的组件。一经捐赠，这些组件就可进行定制，以添加新功能或者进行扩展，从而创建出新的组件。表A总结了适用于Cocoon的一些常用生成器、转换器和序列化器。

表A

可由Cocoon使用的部分组件

如所你见，Cocoon的功能并非只是简单地将数据格式化成HTML。在未来的文章中，我们将研究如何在Cocoon环境中创建和处理文档，并更详 细地介绍在这个环境中工作所牵涉的问题。就目前来说，你只需理解Cocoon是针对多种目的来捕捉、呈现和递送Web内容的一种方式。

具体例子如下：

　　新规范主要交付了以下新特性：

　　开发的简易性
可插拔性和可扩展性
异步支持
安全性增强
其他杂项变化

　　很明显，与其他技术相比，servlets 在 Java Enterprise Edition 家族中有着更广泛的应用。Servlets 保留了其简洁性和能够处理 HTTP 请求并向 web 客户机传回响应的优点。Servlets 可以用于实现简单和小型应用程序的业务逻辑。在 web 框架中，servlets 作为所有传入请求的入口点(即 controller servlet);因此，所有流行框架都是在原始的 servlets 上建立的。Servlet 3.0 中的新增特性旨简化 servlet 应用程序的开发，并让 servlet 开发人员和框架开发人员从中受益。在以下章节中，我们将详细介绍每个新增特性，并讨论如何使用它们来开发更优秀的应用程序。

　　开发的简易性

　　开发的简易性是任何技术成功的关键因素。Servlet 3.0 API 通过使用 JSR 175 注释 集中解决开发简易性问题，允许开发人员采用声明式的编程方式。这意味着您可以通过使用像 @Servlet 或者 @ServletFilter 这样的适当注释对类进行注释来快速开发一个 servlet 或者过滤器类。注释不仅使 servlet、过滤器和侦听器类的编码更容易，而且，即使应用程序存档可能有 servlet、过滤器或者上下文侦听器类也可以选择用于 web 应用程序的开发部署描述符。Web 容器负责处理各种注释，其位置在 WEB-INF/classes 目录下的各个类中、WEB-INF/lib 目录下的 .jar 文件中、或者应用程序类路径中任何可以找到的类中。

　　注释与部署描述符

　　值得注意的是，部署描述符优先于注释。换句话说，部署描述符覆盖通过注释机制所规定的配置信 息。Web 部署描述符的 3.0 版本在 web-app 元素上包含一种名为 metadata-complete 的新属性。该属性定义了 web 描述符是否完整，或者 web 应用程序的类文件是否针对指定部署信息的注释而进行检查。如果该属性被设置为 true，则部署工具必须忽略类文件中所存在的任何 servlet 注释，并只使用描述符中所提及的配置细节。否则，如果没有指定该值或者该值被设置为 false，容器必须针对注释而扫描应用程序的所有类文件。这个属性提供了在应用程序启动阶段启用或者禁用注释扫描以及对注释的处理。

　　在 Servlet 3.0 中所引入的所有注释都可以在 javax.servlet.http.annotation 和 javax.servlet.http.annotation.jaxrs 软件包中找到。以下章节阐述 Servlet 3.0 中注释的完整集合：

　　@Servlet：javax.servlet.http.annotation.Servlet 是一个类级别的注释，确认经过注释的类为一个 servlet 并保存关于所声明的 servlet 的元数据。urlMappings 属性是指定 URL 模式(调用该 servlet)的 @Servlet 的强制属性。当接收到了一个请求时，容器将请求中的 URL 与 servlet 的 urlMappings 进行匹配，且如果 URL 模式匹配，则调用相应的 servlet 以响应该项请求。该注释的所有其他属性都是可选的，并带有合理的默认值。Servlet 类中必须有一种使用像 GET、PUT、POST、HEAD 或者 DELETE 这样的 HttpMethod 注释进行注释的方法。这些方法应将 HttpServletRequest 和 HttpServletResponse 作为方法参数。与以前的版本相反，servlets 3.0 的版本可以作为简单传统 Java 对象(Plain Old Java Objects，POJOs)而实现;也就是 servlets 不必再扩展像 HTTPServlet 或者 GenericServlet 这样的基础 servlet 实现类。

　　为了进行比较，在此给出了使用传统 Servlet 2.5 API 编写的 Java servlet 代码片段，如下所示。在 Servlet 2.5 中，只要在部署描述符中配置了 servlet 的详细信息，web 容器就将初始化 servlet。

　　Deployment descriptor (web.xml)

      这里给出的是使用 Servlet 3.0 API 编写的较为简化的版本。当 MyServlet 使用 @Servlet 注释而被注释为一个 servlet 时，则在 web 容器的启动期间对其初始化。注意，在这种情况下部署描述符是可选的。

     Deployment descriptor (web.xml)

     optional

　　@ServletFilter 和 @FilterMapping：您可以使用 javax.servlet.http.annotation.ServletFilter 注释来注释过滤器类，从而轻松创建一个 servlet 过滤器。该注释封装正被声明的过滤器的有关元数据。在过滤器类上具有 @FilterMapping 注释也是强制性的。@FilterMapping 注释定义用于过滤器的 URL 模式。@ServletFilter 的所有其他属性都是可选的，并带有合理的默认值。V3.0 过滤器类现在类似 POJO 类，并且没有用于这些类所需的 Filter 接口或者非参数公用构造器。以下给出了使用 Servlet v2.5 API 的过滤器类的代码片段：

    Deployment descriptor (web.xml)

　　　使用 Servlet 3.0 编写的一个示例过滤器类如下所示。因为该类使用 ServletFilter 注释，所以容器将 MyFilter 标记为一个过滤器类。MyFilter 截取所有收到的请求，其中该请求的 URL 匹配模式 /foo。Servlet 3.0 为过滤器配置提供了可选的部署描述符。

　　@InitParam：该注释可以用来定义必须传递给 servlet 或者过滤器类的任意初始化参数。它是 @Servlet 和 @ServletFilter 注释的一个属性。以下代码示例解释了如何将具有 english 值、称作 lang 的初始化参数传递给一个 servlet 类。

@ServletContextListener：javax.servlet.http.annotation.ServletContextListener 注释将该类声明为一个 servlet 上下文侦听器。当 web 容器创建或者销毁 ServletContext 时，该上下文侦听器接收注释。上下文侦听器是一个 POJO 类，且不必实现 ServletContextListener 接口。使用 Servlet 2.5 API 编写的侦听器类如下所示。当且仅当您在部署描述符中配置了该侦听器类，容器才识别它。

     Deployment Descriptor (web.xml)

　　使用 Servlet 3.0 API 编写的一个得到极大简化的侦听器类，如下所示。

      Deployment Descriptor (web.xml)

     optional

How do I set the Transaction Timeout?

Transaction timeout (unit is always seconds) can be configured in various ways:

This argument is the same no matter if you are using JBossTM(<=4.0.5) or JBossJTA-Arjuna(>=4.2).

• Globally: You can change this behavior globally by modifying the TransactionManagerService in /conf/jboss-service.xml (or /deploy/jta-service.xml for 4.0.3)

Version <= 4.0.5

This part is the same for either JBossTM or JBossJTA and is the same for ejb2 and ejb3

• Per-method basis: Modifying the <transaction-timeout> element inside the <method> element of a session or entity bean. This is located in the META-INF/jboss.xml deployment descriptor of a session bean. When the transaction timeout is specified at the method level, it overrides the default timeout. Further information about this element can be found in jboss-x.x.x/docs/dtd/jboss_4_0.dtd. Example taken from the testsuite:

• Using BMT: Calling javax.transaction.UserTransaction.setTransactionTimeout(int seconds). Please, be aware that this only applies to transactions started after this invocation on the same thread. Example:

@TransactionTimeout(1500)

趁热打铁，接着上面的再发一个实例：
<?xml version="1.0"?>
<project name="ssh" basedir="." default="usage">
      <property name="name" value="ssh"/>
      <property name="war.dir" value="war"/>
      <property name="src.dir" value="src"/>
      <property name="client.dir" value="client"/>
      <property name="build.dir" value=".classes"/>
      <property name="webcontent.dir" value="WebContent"/>
      <property name="prjlib.dir" value="lib"/>   
      <property name="webcontentlib.dir" value="${webcontent.dir}/WEB-INF/lib"/>
      <property name="weblib.dir" value="${war.dir}/WEB-INF/lib"/>
      <property name="dist.dir" value="dist"/>
      <property environment="env"/>
      <property name="tomcat.home" value="${env.CATALINA_HOME}"/>
      <property name="webapp.dist" value="${dist.dir}/webapps"/>   
      <path id="master-classpath">
          <fileset dir="${webcontentlib.dir}">
              <include name="hibernate3.jar"/>
              <include name="spring.jar"/>            
              <include name="struts.jar"/>            
              <include name="struts-el.jar"/>            
              <include name="struts-menu-2.4.2.jar"/>            
              <include name="acegi-security-1.0.2.jar"/>            
              <include name="activation.jar"/>            
              <include name="antlr.jar"/>            
              <include name="antlr-2.7.6.jar"/>            
              <include name="asm.jar"/>            
              <include name="aspectjweaver-1.5.2.jar"/>            
              <include name="cglib-2.1.3.jar"/>            
              <include name="commons-beanutils.jar"/>            
              <include name="commons-codec-1.3.jar"/>            
              <include name="commons-collections.jar"/>            
              <include name="commons-dbcp.jar"/>            
              <include name="commons-digester.jar"/>            
              <include name="commons-fileupload.jar"/>            
              <include name="commons-io.jar"/>   
              <include name="commons-lang.jar"/>            
              <include name="commons-logging-1.1.jar"/>            
              <include name="commons-pool.jar"/>            
              <include name="commons-validator.jar"/>            
              <include name="displaytag-1.1.jar"/>            
              <include name="dom4j-1.6.1.jar"/>            
              <include name="dwr.jar"/>            
              <include name="ehcache-1.2.3.jar"/>            
              <include name="itext-1.4.jar"/>            
              <include name="jakarta-oro.jar"/>            
              <include name="jstl.jar"/>            
              <include name="jta.jar"/>            
              <include name="log4j-1.2.11.jar"/>            
              <include name="mail.jar"/>            
              <include name="oscache-2.3.2.jar"/>            
              <include name="mysql-connector-java-5.0.3-bin.jar"/>            
              <include name="sitemesh-2.2.1.jar"/>            
              <include name="standard.jar"/>            
              <include name="urlrewrite-3.0-beta.jar"/>            
              <include name="velocity-1.4.jar"/>            
              <include name="velocity-tools-view-1.1.jar"/>            
          </fileset>
          <fileset dir="${prjlib.dir}/servletapi-2.3">
              <include name="servletapi-2.3.jar"/>
          </fileset>        
      </path>   
      <target name="usage">
          <echo message=""/>
          <echo message="Spring JPetStore build file"/>
          <echo message="------------------------------------------------------"/>
          <echo message=""/>
          <echo message="Available targets are:"/>
          <echo message=""/>
          <echo message="clean      --> Clean output dirs"/>
          <echo message="build      --> Compile main Java sources and copy libraries"/>
          <echo message="warfile --> Build the web application archive"/>
          <echo message="all        --> Clean, build, warfile"/>
          <echo message=""/>
      </target>   
      <target name="clean" description="Clean output dirs (build, weblib, dist)">
          <delete dir="${build.dir}"/>
          <delete dir="${weblib.dir}"/>
          <delete dir="${war.dir}"/>
          <delete dir="${dist.dir}"/>
          <delete file="client/${name}.jar"/>
      </target>
      <target name="build" description="Compile main source tree java files into class files, generate jar files">
          <mkdir dir="${build.dir}"/>
          <mkdir dir="${war.dir}"/>
          <javac destdir="${build.dir}" source="1.3" target="1.3" debug="true"
                  deprecation="false" optimize="false" failonerror="true">
              <src path="${src.dir}"/>
              <classpath refid="master-classpath"/>
          </javac>
          <mkdir dir="${weblib.dir}"/>
          <mkdir dir="${war.dir}/WEB-INF/classes"/>
          <jar jarfile="${weblib.dir}/${name}.jar" compress="true" basedir="${build.dir}"/>
          <copy todir="${war.dir}" preservelastmodified="true">
              <fileset dir="${webcontent.dir}">
                  <include name="**/**"/>
                  <include name="**.**"/>
              </fileset>
          </copy>
          <copy todir="${war.dir}/WEB-INF/classes" preservelastmodified="true">
              <fileset dir="${src.dir}">
                  <include name="*.xml"/>
                  <include name="**/*.properties"/>
                  <include name="**/*.vm"/>
                  <exclude name="**/.*"/>
              </fileset>
          </copy>        
      
          <copy file="${weblib.dir}/${name}.jar" tofile="${client.dir}/${name}.jar"/>
      </target>
      <target name="dist" depends="warfile">
          <!--
              Delegate to warfile target by depending on it. dist is just to offer
              a generic target name across all Spring sample apps that may be used
              for autobuilds testing.
          -->
      </target>
      <target name="warfile" depends="build" description="Build the web application archive">
          <mkdir dir="${dist.dir}"/>
          <war warfile="${dist.dir}/${name}.war" basedir="${war.dir}" webxml="${webcontent.dir}/WEB-INF/web.xml">
              <include name="*"/>
              <include name="images/**"/>
              <include name="common/**"/>
              <include name="decorators/**"/>
              <include name="scripts/**"/>
              <include name="styles/**"/>
              <include name="WEB-INF/*.*"/>
              <include name="WEB-INF/lib/**"/>
              <include name="WEB-INF/pages/**"/>
              <include name="WEB-INF/classes/**"/>
              <exclude name="WEB-INF/web.xml"/>
          </war>
      </target>
      <target name="all" depends="clean,build,warfile" description="Clean,build,warfile"/>
</project>
在Eclipse中使用Ant Ant是Java平台下非常棒的批处理命令执行程序，能非常方便地自动完成编译，测试，打包，部署等等一系列任务，大大提高开发效率。如果你现在还没有开始使用Ant，那就要赶快开始学习使用，使自己的开发水平上一个新台阶。

Eclipse中已经集成了Ant，我们可以直接在Eclipse中运行Ant。

以前面建立的Hello工程为例，创建以下目录结构：



新建一个build.xml，放在工程根目录下。build.xml定义了Ant要执行的批处理命令。虽然Ant也可以使用其它文件名，但是遵循标准能更使开发更规范，同时易于与别人交流。
通常，src存放Java源文件，classes存放编译后的class文件，lib存放编译和运行用到的所有jar文件，web存放JSP等web文件，dist存放打包后的jar文件，doc存放API文档。
然后在根目录下创建build.xml文件，输入以下内容：

<?xml version="1.0"?>
<project name="Hello world" default="doc">
<!-- properies -->
     <property name="src.dir" value="src" />
     <property name="report.dir" value="report" />
     <property name="classes.dir" value="classes" />
     <property name="lib.dir" value="lib" />
     <property name="dist.dir" value="dist" />
<property name="doc.dir" value="doc"/>
     <!-- 定义classpath -->
     <path id="master-classpath">
         <fileset file="${lib.dir}/*.jar" />
         <pathelement path="${classes.dir}"/>
     </path>
     <!-- 初始化任务 -->
     <target name="init">
     </target>
     <!-- 编译 -->
     <target name="compile" depends="init" description="compile the source files">
         <mkdir dir="${classes.dir}"/>
         <javac srcdir="${src.dir}" destdir="${classes.dir}" target="1.4">
             <classpath refid="master-classpath"/>
         </javac>
     </target>
     <!-- 测试 -->
     <target name="test" depends="compile" description="run junit test">
         <mkdir dir="${report.dir}"/>
         <junit printsummary="on"
                 haltonfailure="false"
                 failureproperty="tests.failed"
                 showoutput="true">
             <classpath refid="master-classpath" />
             <formatter type="plain"/>
             <batchtest todir="${report.dir}">
                 <fileset dir="${classes.dir}">
                     <include name="**/*Test.*"/>
                 </fileset>
             </batchtest>
         </junit>
         <fail if="tests.failed">
         ***********************************************************
         ****   One or more tests failed!   Check the output ...   ****
         ***********************************************************
         </fail>
     </target>
     <!-- 打包成jar -->
     <target name="pack" depends="test" description="make .jar file">
      <mkdir dir="${dist.dir}" />
         <jar destfile="${dist.dir}/hello.jar" basedir="${classes.dir}">
             <exclude name="**/*Test.*" />
             <exclude name="**/Test*.*" />
         </jar>
     </target>
     <!-- 输出api文档 -->
     <target name="doc" depends="pack" description="create api doc">
      <mkdir dir="${doc.dir}" />
      <javadoc destdir="${doc.dir}"
             author="true"
             version="true"
             use="true"
             windowtitle="Test API">
             <packageset dir="${src.dir}" defaultexcludes="yes">
                 <include name="example/**" />
             </packageset>
             <doctitle><![CDATA[<h1>Hello, test</h1>]]></doctitle>
             <bottom><![CDATA[<i>All Rights Reserved.</i>]]></bottom>
             <tag name="todo" scope="all" description="To do:" />
         </javadoc>
     </target>
</project>

以上xml依次定义了init（初始化），compile（编译），test（测试），doc（生成文档），pack（打包）任务，可以作为模板。
选中Hello工程，然后选择“Project”，“Properties”，“Builders”，“New…”，选择“Ant Build”：

填入Name：Ant_Builder；Buildfile：build.xml；BaseDirectory：${workspace_loc: /Hello}（按“BrowseWorkspace”选择工程根目录），由于用到了junit.jar包，搜索Eclipse目录，找到 junit.jar，把它复制到Hello/lib目录下，并添加到Ant的Classpath中：

然后在Builder面板中钩上Ant_Build，去掉Java Builder：

再次编译，即可在控制台看到Ant的输出：

Buildfile: F:\eclipse-projects\Hello\build.xml
init:
compile:
        [mkdir] Created dir: F:\eclipse-projects\Hello\classes
        [javac] Compiling 2 source files to F:\eclipse-projects\Hello\classes
test:
        [mkdir] Created dir: F:\eclipse-projects\Hello\report
        [junit] Running example.HelloTest
        [junit] Tests run: 1, Failures: 0, Errors: 0, Time elapsed: 0.02 sec
pack:
        [mkdir] Created dir: F:\eclipse-projects\Hello\dist
          [jar] Building jar: F:\eclipse-projects\Hello\dist\hello.jar
doc:
        [mkdir] Created dir: F:\eclipse-projects\Hello\doc
      [javadoc] Generating Javadoc
      [javadoc] Javadoc execution
      [javadoc] Loading source files for package example...
      [javadoc] Constructing Javadoc information...
      [javadoc] Standard Doclet version 1.4.2_04
      [javadoc] Building tree for all the packages and classes...
      [javadoc] Building index for all the packages and classes...
      [javadoc] Building index for all classes...
      [javadoc] Generating F:\eclipse-projects\Hello\doc\stylesheet.css...
      [javadoc] Note: Custom tags that could override future standardtags:   @todo. To avoid potential overrides, use at least one periodcharacter (.) in custom tag names.
      [javadoc] Note: Custom tags that were not seen:   @todo
BUILD SUCCESSFUL
Total time: 11 seconds

Ant依次执行初始化，编译，测试，打包，生成API文档一系列任务，极大地提高了开发效率。将来开发J2EE项目时，还可加入部署等任务。并且，即使脱离了Eclipse环境，只要正确安装了Ant，配置好环境变量ANT_HOME=<Ant解压目录&gt;， Path=…;%ANT_HOME%\bin，在命令行提示符下切换到Hello目录，简单地键入ant即可。

Byte Code Engineering Library (BCEL)，这是Apache Software Foundation 的Jakarta 项目的一部分。

正在装载数据……

BCEL 是 Java classworking 最广泛使用的一种框架,它可以让您深入 JVM 汇编语言进行类操作的细节。BCEL与Javassist 有不同的处理字节码方法，BCEL在实际的JVM 指令层次上进行操作(BCEL拥有丰富的JVM 指令级支持)而Javassist 所强调的源代码级别的工作。

http://sourceforge.net/projects/bcel

Javassist:使字节码工程变得简单(Zz)　：

使用Javassist对.class文件进行修改(Zz)　：

最 近重新再看<Inside JVM>，对JAVA编译成的字节码结构很感兴趣，希望找个工具能够对.class文件进行的解析和查看。没找到，倒发现javaassist可以 对字节码进行操作和修改。此工具是JBOSS项目的一部分,JBOSS实现AOP的基础。呵呵，开眼界了，原来我们可以直接对字节码文件进行修改，哪怕不 知道源文件（跟反编译完全不同）。一个简单例子：

import javassist.*;
class Hello {
    public void say() {
        System.out.println("Hello");
    }
}

public class Test {
    public static void main(String[] args) throws Exception {
        ClassPool cp = ClassPool.getDefault();
        CtClass cc = cp.get("Hello");
        CtMethod m = cc.getDeclaredMethod("say");
        m.setBody("{System.out.println(""shit"");}");
        m.insertBefore("System.out.println(""fuck"");");
        Class c = cc.toClass();
        Hello h = (Hello)c.newInstance();
        h.say();
    }
}

编译运行此文件，输出：

fuck

shit

我们在

 CtMethod m = cc.getDeclaredMethod("say");
  m.setBody("{System.out.println(""shit"");}");

  m.insertBefore("System.out.println(""fuck"");");

修改了say()方法，改成了

System.out.println("fuck");

System.out.println("shit");

这里的ClassPool是CtClass的容器，它读取class文件，并根据要求保存CtClass的结构以便日后使用，默认状态下是从当前的类装载器获得，当然你可以指定：

pool.insertClassPath("/usr/local/javalib");

当然，不仅仅是修改方法，你还可以新建一个class,利用makeClass()方法，如：

ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.makeClass("Point");

还可以新增方法，下面是sample里的一个例子，同样的：

package sample;

import javassist.*;
import java.lang.reflect.*;

/*
   A very simple sample program

   This program overwrites sample/Test.class (the class file of this
   class itself) for adding a method g().  If the method g() is not
   defined in class Test, then this program adds a copy of
   f() to the class Test with name g().  Otherwise, this program does
   not modify sample/Test.class at all.

   To see the modified class definition, execute:

   % javap sample.Test

   after running this program.
*/
public class Test {
    public int f(int i) {
     i++;
    return i;
    }

    public static void main(String[] args) throws Exception {
 ClassPool pool = ClassPool.getDefault();

 CtClass cc = pool.get("sample.Test");
 Test test=new Test();
 Class c=test.getClass();
 Method []method=c.getDeclaredMethods();
 for(int i=0;i<method.length;i++){
  System.out.println(method[i]);
 }
 try {
     cc.getDeclaredMethod("g");
     System.out.println("g() is already defined in sample.Test.");
 }
 catch (NotFoundException e) {
     /* getDeclaredMethod() throws an exception if g()
      * is not defined in sample.Test.
      */
     CtMethod fMethod = cc.getDeclaredMethod("f");
     CtMethod gMethod = CtNewMethod.copy(fMethod, "g", cc, null);
     cc.addMethod(gMethod);
     cc.writeFile(); // update the class file
     System.out.println("g() was added.");
 }
    }
}
第一次运行时，因为Test里并没有g()方法，所以执行

 CtMethod fMethod = cc.getDeclaredMethod("f");
     CtMethod gMethod = CtNewMethod.copy(fMethod, "g", cc, null);  //把f方法复制给g
     cc.addMethod(gMethod);
     cc.writeFile(); //更新class文件

     System.out.println("g() was added.");
打印：g() was added

第2次运行时，因为以上步骤已经在class文件中增加了一个g方法，所以

 System.out.println("g() is already defined in sample.Test.");
打印：g() is already defined in sample.Test

Javassist不仅能修改你自己的class文件，而且可以同样修改JDK自带的类库（废话，类库也是人写的^_^）具体请看它的tutorial。

Javassist 官方网站： http://www.csg.is.titech.ac.jp/~chiba/javassist/

import java.io.*;
import java.sql.*;
import java.util.*;
import java.util.Date;

 /*
  * 该类只能创建一个实例，其它对象能够调用其静态方法（也称为类方法）获得该唯一实例的引用。
  * DBConnectionManager类的建构函数是私有的，这是为了避免其它对象创建该类的实例.
  * DBConnectionManager类的客户程序可以调用getInstance()方法获得对该类唯一实例的引用。
  * 类的唯一实例在getInstance()方法第一次被调用期间创建，此后其引用就一直保存在静态变量
  * instance中。每次调用getInstance()都增加一个DBConnectionManager的客户程序计数。
  * 即，该计数代表引用DBConnectionManager唯一实例的客户程序总数，它将被用于控制连接池的
  * 关闭操作。 该类实例的初始化工作私有方法init()完成。其中 getResourceAsStream()方法
  * 用于定位并打开外部文件。外部文件的定位方法依赖于类装载器的实现。标准的本地类装载器查找操
  * 作总是开始于类文件所在路径，也能够搜索CLASSPATH中声明的路径。db.properties是一个属性
  * 文件，它包含定义连接池的键-值对。可供定义的公用属性如下：
  *   drivers 以空格分隔的JDBC驱动程序类列表""
  *   logfile 日志文件的绝对路径
  *  其它的属性和特定连接池相关，其属性名字前应加上连接池名字：
  *  < poolname>.url 数据库的 JDBC URL
  *  < poolname>.maxconn 允许建立的最大连接数，0表示没有限制
  *  < poolname>.user 用于该连接池的数据库帐号
  *  < poolname>.password 相应的密码""
  * 其中url属性是必需的，而其它属性则是可选的。数据库帐号和密码必须合法。用于Windows平台的
  * db.properties文件示例如下：
  *  drivers=com.microsoft.jdbc.sqlserver.SQLServerDriver
  *  logfile=D:""log.txt
  *  access.maxconn=20
  *  access.url=jdbc:microsoft:sqlserver://localhost:1433;databasename=web
  *  access.user=sa
  *  access.password=sa 
  * 注意在Windows路径中的反斜杠必须输入2个，这是由于属性文件中的反斜杠同时也是一个转义字符。
  * init()方法在创建属性对象并读取db.properties文件之后，就开始检查logfile属性。如果属
  * 性文件中没有指定日志文件，则默认为当前目录下的DBConnectionManager.log文件。如日志文
  * 件无法使用，则向System.err输出日志记录。装载和注册所有在drivers属性中指定的JDBC驱动
  * 程序loadDrivers()方法实现。该方法先用StringTokenizer将drivers属性值分割为对应于驱
  * 动程序名称的字符串，然后依次装载这些类并创建其实例，最后在DriverManager中注册该实例并把
  * 它加入到一个私有的向量drivers。向量drivers将用于关闭服务时从DriverManager取消所有
  * JDBC 驱动程序的注册。init()方法的最后一个任务是调用私有方法createPools()创建连接池对
  * 象。createPools()方法先创建所有属性名字的枚举对象（即Enumeration对象，该对象可以想象
  * 为一个元素系列，逐次调用其nextElement()方法将顺序返回各元素），然后在其中搜索名字以“.url”
  * 结尾的属性。对于每一个符合条件的属性，先提取其连接池名字部分，进而读取所有属于该连接池的属性，
  * 最后创建连接池对象并把它保存在实例变量pools中。散列表（Hashtable类 ）pools实现连接池名字
  * 到连接池对象之间的映射，此处以连接池名字为键，连接池对象为值。 为便于客户程序从指定连接池获
  * 得可用连接或将连接返回给连接池，类DBConnectionManager提供了方法getConnection()和
  * freeConnection()。所有这些方法都要求在参数中指定连接池名字，具体的连接获取或返回操作则调
  * 用对应的连接池对象完成。为实现连接池的安全关闭，DBConnectionManager提供了方法release()。
  * 在上面我们已经提到，所有DBConnectionManager的客户程序都应该调用静态方法getInstance()
  * 以获得该管理器的引用，此调用将增加客户程序计数。客户程序在关闭时调用release()可以递减该计数。
  * 当最后一个客户程序调用release()，递减后的引用计数为0，就可以调用各个连接池的release()方法
  * 关闭所有连接了。管理类release()方法最后的任务是撤销所有JDBC驱动程序的注册。
  */

/**
 * 管理类DBConnectionManager支持对一个或多个由属性文件定义的数据库连接
 * 池的访问.客户程序可以调用getInstance()方法访问本类的唯一实例.
 */
public class DBConnectionManager {
 static private DBConnectionManager instance; // 唯一实例

 static private int clients;

 private Vector drivers = new Vector();

 private PrintWriter log;

 private Hashtable pools = new Hashtable();

 /**
  * 返回唯一实例.如果是第一次调用此方法,则创建实例
  * @return DBConnectionManager 唯一实例
  */
 static synchronized public DBConnectionManager getInstance() {
  if (instance == null) {
   instance = new DBConnectionManager();
  }
  clients++;
  return instance;
 }

 /**
  * 建构函数私有以防止其它对象创建本类实例
  */
 private DBConnectionManager() {
  init();
 }

 /**
  * * 将连接对象返回给由名字指定的连接池
  * @param name在属性文件中定义的连接池名字
  * @param con连接对象""""r
  */
 public void freeConnection(String name, Connection con) {
  DBConnectionPool pool = (DBConnectionPool) pools.get(name);
  if (pool != null) {
   pool.freeConnection(con);
  }
 }

 /**
  * 获得一个可用的(空闲的)连接.如果没有可用连接,且已有连接数小于最大连接数 053 * 限制,则创建并返回新连
  * @param name在属性文件中定义的连接池名字 056 *
  * @return Connection 可用连接或null 057
  */
 public Connection getConnection(String name) {
  DBConnectionPool pool = (DBConnectionPool) pools.get(name);
  if (pool != null) {
   return pool.getConnection();
  }
  return null;
 }

 /**
  * 获得一个可用连接.若没有可用连接,且已有连接数小于最大连接数限制,
  * 则创建并返回新连接.否则,在指定的时间内等待其它线程释放连接.
  * @param name 连接池名字 071 *
  * @param time以毫秒计的等待时间""""r
  * @return Connection 可用连接或null
  */
 public Connection getConnection(String name, long time) {
  DBConnectionPool pool = (DBConnectionPool) pools.get(name);
  if (pool != null) {
   return pool.getConnection(time);
  }
  return null;
 }

 /**
  * 关闭所有连接,撤销驱动程序的注册""""r
  */
 public synchronized void release() {
  // 等待直到最后一个客户程序调用
  if (--clients != 0) {
   return;
  }

  Enumeration allPools = pools.elements();
  while (allPools.hasMoreElements()) {
   DBConnectionPool pool = (DBConnectionPool) allPools.nextElement();
   pool.release();
  }
  Enumeration allDrivers = drivers.elements();
  while (allDrivers.hasMoreElements()) {
   Driver driver = (Driver) allDrivers.nextElement();
   try {
    DriverManager.deregisterDriver(driver);
    log("撤销JDBC驱动程序 " + driver.getClass().getName() + "的注册");
   } catch (SQLException e) {
    log(e, "无法撤销下列JDBC驱动程序的注册: " + driver.getClass().getName());
   }
  }
 }

 /**
  * 根据指定属性创建连接池实例.
  * @param props 连接池属性 113
  */
 private void createPools(Properties props) {
  Enumeration propNames = props.propertyNames();
  while (propNames.hasMoreElements()) {
   String name = (String) propNames.nextElement();
   if (name.endsWith(".url")) {
    String poolName = name.substring(0, name.lastIndexOf("."));
    String url = props.getProperty(poolName + ".url");
    if (url == null) {
     log("没有为连接池" + poolName + "指定URL");
     continue;
    }
    String user = props.getProperty(poolName + ".user");
    String password = props.getProperty(poolName + ".password");
    String maxconn = props.getProperty(poolName + ".maxconn", "0");
    int max;
    try {
     max = Integer.valueOf(maxconn).intValue();
    } catch (NumberFormatException e) {
     log("错误的最大连接数限制: " + maxconn + " .连接池: " + poolName);
     max = 0;
    }
    DBConnectionPool pool = new DBConnectionPool(poolName, url,
      user, password, max);
    pools.put(poolName, pool);
    log("成功创建连接池" + poolName);
   }
  }
 }

 /**
  * 读取属性完成初始化
  */
 private void init() {
  InputStream is = getClass().getResourceAsStream("/db.properties");
  Properties dbProps = new Properties();
  try {
   dbProps.load(is);
  } catch (Exception e) {
   System.err.println("不能读取属性文件. "+"请确保db.properties在CLASSPATH指定的路径中");
   return;
  }
  String logFile = dbProps.getProperty("logfile","DBConnectionManager.log");
  try {
   log = new PrintWriter(new FileWriter(logFile, true), true);
  } catch (IOException e) {
   System.err.println("无法打开日志文件: " + logFile);
   log = new PrintWriter(System.err);
  }
  loadDrivers(dbProps);
  createPools(dbProps);
 }

 /**
  * 装载和注册所有JDBC驱动程序
  * @param props属性
  */
 private void loadDrivers(Properties props) {
  String driverClasses = props.getProperty("drivers");
  StringTokenizer st = new StringTokenizer(driverClasses);
  while (st.hasMoreElements()) {
   String driverClassName = st.nextToken().trim();
   try {
    Driver driver = (Driver) Class.forName(driverClassName).newInstance();
    DriverManager.registerDriver(driver);
    drivers.addElement(driver);
    log("成功注册JDBC驱动程序" + driverClassName);
   } catch (Exception e) {
    e.printStackTrace();
    log("无法注册JDBC驱动程序: " + driverClassName + ", 错误: " + e);
   }
  }
 }

 /**
  * 将文本信息写入日志文件
  */
 private void log(String msg) {
  log.println(new Date() + ": " + msg);
 }

 /**
  * 将文本信息与异常写入日志文件
  */
 private void log(Throwable e, String msg) {
  log.println(new Date() + ": " + msg);
  e.printStackTrace(log);
 }

 // ///////////////////////////////////////////////////////////////////////////////////////////////////////
 // ///////////////////////////////////////////////////////////////////////////////////////////////////////
 /*
  * DBConnectionPool实现，它表示指向某个数据库的连接池。数据库由JDBC URL标识。一个JDBCURL由三部分组成：协议标识（总是jdbc），
  * 驱动程序标识（如odbc、idb、oracle等），数据库标识（其格式依赖于驱动程序）。例如，jdbc:odbc:demo，即是一个指向demo数据
  * 库的JDBCURL，而且访问该数据库要使用JDBC-ODBC驱动程序。每个连接池都有一个供客户程序使用的名字以及可选的用户帐号、密码、最
  * 大连接数限制。如果Web应用程序所支持的某些数据库操作可以被所有用户执行，而其它一些操作应由特别许可的用户执行，则可以为两类操作
  * 分别定义连接池，两个连接池使用相同的JDBC URL，但使用不同的帐号和密码。类DBConnectionPool的建构函数需要上述所有数据作为其
  * 参数。客户程序可以使用DBConnectionPool
  * 类提供的两个方法获取可用连接。两者的共同之处在于：如连接池中存在可用连接，则直接返回，否则创建新的连接并返回。如果没有可用连接
  * 且已有连接总数等于最大限制数，第一个方法将直接返回null，而第二个方法将等待直到有可用连接为止。所有的可用连接对象均登记在名为
  * freeConnections的向量（Vector）中。如果向量中有多于一个的连接，getConnection()总是选取第一个。同时，由于新的可用连接总
  * 是从尾部加入向量，从而使得数据库连接由于长时间闲置而被关闭的风险减低到最小程度。 第一个getConnection()在返回可用连接给客户
  * 程序之前，调用了isClosed()方法验证连接仍旧有效。如果该连接被关闭或触发异常，getConnection()递归地调用自己以尝试获取另外的
  * 可用连接。如果在向量freeConnections中不存在任何可用连接，getConnection()方法检查是否已经指定最大连接数限制。如已经指定，
  * 则检查当前连接数是否已经到达极限。此处maxConn为0表示没有限制。如果没有指定最大连接数限制或当前连接数小于该值，该方法尝试创建
  * 新的连接。如创建成功，则增加已使用连接的计数并返回，否则返回空值。创建新连接由newConnection()方法实现。
  * 创建过程与是否已经指定数据库帐号、密码有关。JDBC的DriverManager类提供多个getConnection()方法，这些方法要用到JDBC URL
  * 与其它一些参数，如用户帐号和密码等。DriverManager将使用指定的JDBC URL确定适合于目标数据库的驱动程序及建立连接。
  * 第二个getConnection()方法需要一个以毫秒为单位的时间参数，该参数表示客户程序能够等待的最长时间。建立连接的具体操
  * 作仍旧由第一个getConnection()方法实现。该方法执行时先将startTime初始化为当前时间。在while循环中尝试获得一个连接。如果失
  * 败，则以给定的时间值为参数调用wait()。wait()的返回可能是由于其它线程调用notify()或notifyAll()，也可能是由于预定时间已到。
  * 为找出wait()返回的真正原因，程序用当前时间减开始时间（startTime），如差值大于预定时间则返回空值，否则再次调用getConnection()。
  * 把空闲的连接登记到连接池由freeConnection()方法实现，它的参数为返回给连接池的连接对象。该对象被加入到freeConnections
  * 向量的末尾，然后减少已使用连接计数。调用notifyAll()是为了通知其它正在等待可用连接的线程。 许多Servlet引擎为实现安全关闭提供
  * 多种方法。数据库连接池需要知道该事件以保证所有连接能够正常关闭。DBConnectionManager类负协调整个关闭过程，但关闭连接池中所有连
  * 接的任务则由DBConnectionPool类负责。release()方法供DBConnectionManager调用。该方法遍历freeConnections向量并关闭所有连接，
  * 然后从向量中删除这些连接。
  */

 /**
  * 此内部类定义了一个连接池.它能够根据要求创建新连接,直到预定的最""""r
  */
 class DBConnectionPool {
  private int checkedOut;

  private Vector freeConnections = new Vector();

  private int maxConn;

  private String name;

  private String password;

  private String URL;

  private String user;

  /**
   * 创建新的连接池
   * @param name连接池名字
   * @param URL数据库的JDBC URL
   * @param user数据库帐号,或 null
   * @param password密码,或 null
   * @param maxConn此连接池允许建立的最大连接数
   */
  public DBConnectionPool(String name, String URL, String user,
    String password, int maxConn) {
   this.name = name;
   this.URL = URL;
   this.user = user;
   this.password = password;
   this.maxConn = maxConn;
  }

  /**
   * 将不再使用的连接返回给连接池
   * @param con客户程序释放的连接
   */
  public synchronized void freeConnection(Connection con) {
   // 将指定连接加入到向量末尾
   freeConnections.addElement(con);
   checkedOut--;
   notifyAll();
  }

  /**
   * 从连接池获得一个可用连接.如没有空闲的连接且当前连接数小于最大连接 数限制,则创建新连接.
   * 如原来登记为可用的连接不再有效,则从向量删除之,
   * 然后递归调用自己以尝试新的可用连接.
   */
  public synchronized Connection getConnection() {
   Connection con = null;
   if (freeConnections.size() > 0) {// 获取向量中第一个可用连接
    con = (Connection) freeConnections.firstElement();
    freeConnections.removeElementAt(0);
    try {
     if (con.isClosed()) {
      log("从连接池" + name + "删除一个无效连接");
      // 递归调用自己,尝试再次获取可用连接
      con = getConnection();
     }
    } catch (SQLException e) {
     log("从连接池" + name + "删除一个无效连接");
     // 递归调用自己,尝试再次获取可用连接
     con = getConnection();
    }
   } else if (maxConn == 0 || checkedOut < maxConn) {
    con = newConnection();
   }
   if (con != null) {
    checkedOut++;
   }
   return con;
  }

  /**
   * 从连接池获取可用连接.可以指定客户程序能够等待的最长时间 参见前一个getConnection()方法.
   * @param timeout以毫秒计的等待时间限制
   */
  public synchronized Connection getConnection(long timeout) {
   long startTime = new Date().getTime();
   Connection con;
   while ((con = getConnection()) == null) {
    try {
     wait(timeout);
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
    if ((new Date().getTime() - startTime) >= timeout) {// wait()返回的原因是超时
     return null;
    }
   }
   return con;
  }

  /**
   * 关闭所有连接
   */
  public synchronized void release() {
   Enumeration allConnections = freeConnections.elements();
   while (allConnections.hasMoreElements()) {
    Connection con = (Connection) allConnections.nextElement();
    try {
     con.close();
     log("关闭连接池" + name + "中的一个连接");
    } catch (SQLException e) {
     log(e, "无法关闭连接池" + name + "中的连接");
     e.printStackTrace();
    }
   }
   freeConnections.removeAllElements();
  }

  /**
   * 创建新的连接
   */
  private Connection newConnection() {
   Connection con = null;
   try {
    if (user==null||"".equals(user)) {
     con = DriverManager.getConnection(URL);
    } else {
     con = DriverManager.getConnection(URL, user, password);
    }
    log("连接池" + name + "创建一个新的连接");
   } catch (SQLException e) {
    log(e, "无法创建下列URL的连接: " + URL);
    return null;
   }
   return con;
  }
 }

 /////////////////////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////////////////////
}

在sqlserver2000，tomcat5.5验证通过

方法调用！

package com.xinnuo.jdbc;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

Java编程入门类

对于没有Java编程经验的程序员要入门，随便读什么入门书籍都一样，这个阶段需要你快速的掌握Java基础语法和基本用法，宗旨就是“囫囵吞枣不求甚解 ”，先对Java熟悉起来再说。用很短的时间快速过一遍Java语法，连懵带猜多写写代码，要“知其然”。

1、《Java编程思想》


在有了一定的Java编程经验之后，你需要“知其所以然”了。这个时候《Java编程思想》是一本让你知其所以然的好书，它对于基本的面向对象知 识有比较清楚的交待，对Java基本语法，基本类库有比较清楚的讲解，可以帮你打一个良好的Java编程基础。这本书的缺点是实在太厚，也比较罗嗦，不适 合现代人快节奏学习，因此看这本书要懂得取舍，不是每章每节都值得一看的，挑重点的深入看就可以了。

2、《Agile Java》中文版


这本书是出版社送给我的，我一拿到就束之高阁，放在书柜一页都没有翻过，但是前两天整理书柜的时候，拿出来一翻，竟然发现这绝对是一本好书！这本 书一大特点是以单元测试和TDD来贯穿全书的，在教你Java各种重要的基础知识的过程中，潜移默化的影响你的编程思维走向敏捷，走向TDD。另外这本书 成书很新，以JDK5.0的语法为基础讲解，要学习JDK5.0的新语法也不错。还有这本书对于内容取舍也非常得当，Java语言毕竟类库庞大，可以讲的 内容太多，这本书选择的内容以及内容的多寡都很得当，可以让你以最少的时间掌握Java最重要的知识，顺便培养出来优秀的编程思路，真是一本不可多得的好 书。

虽然作者自己把这本书定位在入门级别，但我不确定这本书用来入门是不是稍微深了点。

Java编程进阶类

打下一个良好的Java基础，还需要更多的实践经验积累，我想没有什么捷径。有两本书值得你在编程生涯的这个阶段阅读，培养良好的编程习惯，提高你的代码质量。

1、《重构 改善既有代码的设计》


这本书名气很大，不用多介绍，可以在闲暇的时候多翻翻，多和自己的实践相互印证。这本书对你产生影响是潜移默化的。

2、《测试驱动开发 by Example》


本书最大特点是很薄，看起来没有什么负担。你可以找一个周末的下午，一边看，一边照做，一个下午就把书看完，这本书的所有例子跑完了。这本书的作用是通过实战让你培养TDD的思路。

Java架构师之路

到这个阶段，你应该已经非常娴熟的运用Java编程，而且有了一个良好的编程思路和习惯了，但是你可能还缺乏对应用软件整体架构的把握，现在就是你迈向架构师的第一步。

1、《Expert One-on-One J2EE Design and Development》


这本书是Rod Johnson的成名著作，非常经典，从这本书中的代码诞生了springframework。但是好像这本书没有中译本。

2、《Expert One-on-One J2EE Development without EJB》


这本书由gigix组织翻译，多位业界专家参与，虽然署名译者是JavaEye，其实JavaEye出力不多，实在是忝居译者之名。

以上两本书都是Rod Johnson的经典名著，Java架构师的必读书籍。在我所推荐的这些书籍当中，是我看过的最仔细，最认真的书，我当时读这本书几乎是废寝忘食的一气读 完的，有小时候挑灯夜读金庸武侠小说的劲头，书中所讲内容和自己的经验知识一一印证，又被无比精辟的总结出来，读完这本书以后，我有种被打通经脉，功力爆 增的感觉。

但是后来我看过一些其他人的评价，似乎阅读体验并没有我那么high，也许是因为每个人的知识积累和经验不同导致的。我那个时候刚好是经验知识积累已经足够丰富，但是还没有系统的整理成型，让这本书一梳理，立刻形成完整的知识体系了。

3、《企业应用架构模式》


Martin的又一本名著，但这本书我只是泛泛的看了一遍，并没有仔细看。这本书似乎更适合做框架的人去看，例如如果你打算自己写一个ORM的 话，这本书是一定要看的。但是做应用的人，不看貌似也无所谓，但是如果有空，我还是推荐认真看看，会让你知道框架为什么要这样设计，这样你的层次可以晋升 到框架设计者的角度去思考问题。Martin的书我向来都是推崇，但是从来都没有像Rod Johnson的书那样非常认真去看。

4、《敏捷软件开发 原则、模式与实践》


Uncle Bob的名著，敏捷的经典名著，这本书比较特别，与其说是讲软件开发过程的书，不如说讲软件架构的书，本书用了很大篇幅讲各种面向对象软件开发的各种模式，个人以为看了这本书，就不必看GoF的《设计模式》了。

软件开发过程

了解软件开发过程不单纯是提高程序员个人的良好编程习惯，也是增强团队协作的基础。

1、《UML精粹》


UML其实和软件开发过程没有什么必然联系，却是软件团队协作沟通，撰写软件文档需要的工具。但是UML真正实用的图不多，看看这本书已经足够了，完全没有必要去啃《UML用户指南》之类的东西。要提醒大家的是，这本书的中译本翻译的非常之烂，建议有条件的看英文原版。

2、《解析极限编程 拥抱变化》XP


这是Kent Beck名著的第二版，中英文对照。没什么好说的，必读书籍。

3、《统一软件开发过程》UP


其实UP和敏捷并不一定冲突，UP也非常强调迭代，测试，但是UP强调的文档和过程驱动却是敏捷所不取的。不管怎么说，UP值得你去读，毕竟在中国真正接受敏捷的企业很少，你还是需要用UP来武装一下自己的，哪怕是披着UP的XP。

4、《敏捷建模》AM


Scott Ambler的名著，这本书非常的progmatic，告诉你怎么既敏捷又UP，把敏捷和UP统一起来了，又提出了很多progmatic的建议和做法。 你可以把《解析极限编程 拥抱变化》、《统一软件开发过程》和《敏捷建模》这三本书放在一起读，看XP和UP的不同点，再看AM是怎么统一XP和UP的，把这三种理论融为一炉，形 成自己的理论体系，那么你也可以去写书了。

软件项目管理

#set($temp="AA")

#set($temp=$temp+$temp)

后来发现怎么调都不通过，最后经过测试发现原来应该是这样子的：

#set($temp="AA")

#set($temp="$temp$temp")

今天记下来，以防日后忘记。