答：ActiveDirectory 支持 LDAP 协议，您可以在 Java 中使用标准的 Java JNDI API 来访问它。LDAP 服务器并非真的必须支持 JNDI API，只要支持 LDAP 协议就可以了。如果您有问题，最有可能是关于您打算如何访问 ActiveDirectory 的配置问题。我已经提供了一个简单的测试案例程序来认证一个 LDAP 服务器的识别名。请确认您的 LDAPAuthentication 类与它基本相同。一般情况下，您对待 ActiveDirectory 不必与对待任何其他的 LDAP 服务器有什么不同。

import java.util.Properties;
import javax.naming.*;  
import javax.naming.directory.*;

//include the JNDI in the classpath. You should use the same JDK used by WebSphere Application server.

class wasLdapAuth
{
public static void main(String[] args)
{
    //***************** user information to be authenticated ********************************
    //*****************Please modify the following three properties accordingly ************
    String ldapHost= "ldap://cliang1.austin.ibm.com:389"; //ldap host + port number
    String DN = "cn=user1, ou=Austin,o=ibm,c=us";   // DN to be authenticated
    String password = "security";  //  DN's password    
    //***************** End of user information
   
    Properties props = new Properties(); 
    props.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");   
//for websphere 4.0 and 5.0
    //props.put(Context.INITIAL_CONTEXT_FACTORY, "com.ibm.jndi.LDAPCtxFactory");    
// for WebSphere 3.5 release
    props.put(Context.SECURITY_AUTHENTICATION, "simple");     //use simple authentication mechanism
    props.put(Context.SECURITY_CREDENTIALS, password); 
    props.put(Context.SECURITY_PRINCIPAL, DN);    
    props.put(Context.PROVIDER_URL, ldapHost); 

    long start = System.currentTimeMillis();
    long end=0;
    long time =0;

    try
        {
        System.out.println("authenticating"); 
        DirContext ctx = new InitialDirContext(props);
        System.out.println("authenticated");
        end = System.currentTimeMillis();
        time = end - start;
        System.out.println( "authentication takes = " + time + " millis");    
        System.out.println("successfully authenticate DN: "+DN);

    }
        catch (Exception ex)
    {
        end = System.currentTimeMillis();
        time = end - start;
        System.out.println("Exception is "+ex.toString());
        ex.printStackTrace();
        System.out.println( "authentication takes = " + time + " millis");   
        System.out.println("fail to authenticate DN: "+DN);
    }
}
}

可以Google一下:tq 郑州

如今写了个抓取中央气象台的天气预报(http://www.tq121.com)

public string GetWeather(string url)
{
   string weacherhtml=String.Empty;
   HttpWebRequest rt=null;
   HttpWebResponse rs=null;
   Stream stream=null;
   StreamReader sr=null;
 
   try
   {
   rt=(HttpWebRequest)WebRequest.Create(url);
   rs=(HttpWebResponse)rt.GetResponse();
   stream=rs.GetResponseStream();
   sr=new StreamReader(stream,System.Text.Encoding.Default);
   weacherhtml=sr.ReadToEnd();
  
}
   catch(Exception ee)
   {
    Response.Write("<script>alert('发生异常')</script>");
   }
   finally
   {
    sr.Close();
    stream.Close();
    rs.Close();
    }

    int start=weacherhtml.IndexOf("郑州");
    int end=weacherhtml.IndexOf("隐私保护");

    return weacherhtml.Substring(start,end-start);

}
别的城市天气情况请调用相应的URL,以及修改城市名称.

引自他人

它的名字是Really Simple Syndication 的的简写。

RSS是XML的一种。所有的RSS文档都遵循 XML 1.0规范, 该规范发布在W3C网站上。

这里是RSS版本历史的一个概要。

在一个RSS文档中，最外层是一个<rss>元素，这个元素必须规定version属性，该属性明确了本文档遵从何种RSS版本规范。如果一个RSS文档以这个规范来表示，那么它的version属性就必须是2.0。

<rss>元素只有一个子元素<channel>，包含了关于这个频道(元数据)和它的内容的一些信息。

样本文件

这里有一些RSS样本文件： RSS 0.91, 0.92 和 2.0。

注意这些样本文件所指向的链接地址和服务器可能已经不再存在。在撰写0.91文档的时候，这个0.91的样本文件就已经创建了。维护一个样本文件的历史也许是一个不错的主意。

关于本文档

本文档完成于2002年秋天，版本为 2.0.1。

它包含从 RSS 0.91 规范(2000年)开始的所有的修改和添加，以及包含在RSS 0.92 （2000年12月）和RSS 0.94（2002年8月）中的新的特性。

详细的文档历史纪录请参阅这里。

本文档中首先介绍必须的和可选的频道元素；接着介绍了<item>的子元素。最后回答了一些经常碰到的问题，并提供了未来的发展路线和RSS扩展的指导方针。

必需的频道元素

下面是一个必须包含的频道(channel)元素的列表，每一个都有一个简单的描述、一个例子、应该出现的位置和更详细描述的链接地址。

01.●　title　
名称：title
描述：频道的名称。它表明别人如何访问你的服务。如果你有一个与你的RSS文件内容一致的HTML网站，你的title元素值应该与你的网站的标题相同。
例子：GoUpstate.com 的新闻大字标题。

02.●　link　
名称：link
描述：对应频道的网站的URL链接地址。
例子：http://www.goupstate.com/ 。

03.●　description　
名称：description
描述：关于频道的描述。
例子：The latest news from GoUpstate.com, a Spartanburg Herald-Journal Web site。
可选的频道元素

下面是一个可选的频道(channel)元素的列表。
01.●　language
名称：language
描述：频道使用的语言。比如，在一个网站上，允许聚合所有的意大利语站点到相应的分组。对于这个元素，可使用的值，参阅 Netscape提供的清单。或者可以参阅W3C定义的 清单。
例子：en-us。

02.●　copyright
名称：copyright
描述：频道内容的版权声明。
例子：Copyright 2002, Spartanburg Herald-Journal

03.●　managingEditor
名称：managingEditor
描述：频道内容责任编辑的电子邮件地址。
例子：geo@herald.com (George Matesky)

04.●　webMaster
名称：webMaster
描述：频道技术支持人员的电子邮件地址。
例子：betty@herald.com (Betty Guernsey)

05.●　pubDate
名称：pubDate
描述：频道内容发布的日期。所有的日期和时间都必须遵循 RFC 822规范, 但年份可以用２个或４个字母表示(首选４个字母)。
例子：Sat, 07 Sep 2002 00:00:01 GMT

06.●　lastBuildDate
名称：lastBuildDate
描述：频道内容的最后修改时间。
例子：Sat, 07 Sep 2002 09:42:31 GMT

07.●　category
名称：category
描述：指定频道所属的一个或多个分类。遵循与item级category元素相同的规则。详见这里。
例子：<category>Newspapers</category>

08.●　generator
名称：generator
描述：表明生成频道的程序名称的字符串。
例子：MightyInHouse Content System v2.3

09.●　docs
名称：docs
描述：指向该RSS文件所用格式说明文档的URL链接地址。
例子：http://blogs.law.harvard.edu/tech/rss。

10.●　cloud
名称：cloud
描述：允许通过注册一个cloud来处理获得频道的更新通知，并为rss种子实现一个轻量级的发布订阅协议，详见这里。
例子：<cloud domain="rpc.sys.com" port="80" path="/RPC2" registerProcedure="pingMe" protocol="soap"/>

11.●　ttl
名称：ttl
描述：ttl是Time to live的缩写，表示生存时间。它表示频道从源更新之前可以缓存的时间。详见 这里。
例子：<ttl>60</ttl>。

12.●　image
名称：image
描述：指定一个可以在频道中显示的GIF、JPEG或者 PNG 图像。详见这里。
例子：。

13.●　rating
名称：rating
描述：频道的 PICS 内容分级信息。
例子： 。

14.●　textInput
名称：textInput
描述：指定一个可以在频道中显示的文本输入框。详见这里。
例子：。

15.●　skipHours
名称：skipHours
描述：提示聚合器，可以跳过那些小时的时间段。详见这里。
例子：。

16.●　skipDays
名称：skipDays
描述：提示聚合器，可以跳过那些天的时间段。详见这里。
例子：。

<channel>的子元素<image>

<image> 是 <channel>的一个可选子元素, 它本身包含了三个必须的和三个可选的子元素。

<url>是一个GIF、JPEG或PNG图像文件的URL链接地址，该图像代表整个频道。

<title>用于描述上面的图像，当频道在HTML中显示时，用于HTML语言中的<img>的alt属性。

<link>是要连接的站点的url，当显示频道时，图像的连接指向该站点。(在实际中，<title>和<link>应该与频道的<title>和<link>有相同的值)。

可选的元素包括<width>和<height>，它们是数字类型，指定图像的宽度和高度，单位为像素。
<description>就是link的TITLE属性中文本，它将在调用网页时显示出来。

图像宽度的最大值为144，默认值为88 。

图像高度的最大值为400，默认值为31 。

<channel>的子元素<cloud>

<cloud> 是 <channel>的一个可选子元素。

它指定一个可以支持rssCloud接口的web服务，rssCloud接口可以在HTTP-POST、XML-RPC或SOAP1.1中实现。

它的目的是允许通过注册一个cloud来处理获得频道的更新通知，从而为RSS feeds实现一个轻量级的发布订阅协议.

<cloud domain="rpc.sys.com" port="80" path="/RPC2" registerProcedure="myCloud.rssPleaseNotify" protocol="xml-rpc" />

在这个例子中，为了请求频道通知，你需要发送一个XML-RPC消息到rpc.sys.com的80端口，路径为/RPC2。调用的程序为为myCloud.rssPleaseNotify。

这个元素的详细说明和 rssCloud 接口说明请参阅 这里。

<channel>子元素<ttl>

<ttl><channel>的一个可选子元素。

ttl是Time to live的缩写，表示生存时间。它表示频道从源重新更新之前可以缓存的时间。这使得rss源可以被一个支持文件共享的网络所管理，例如Gnutella。

例子: <ttl>60</ttl>

<channel>的子元素<textInput>

频道可以选择包含一个<textInput>子元素，它本身包含了四个必须的子元素。

<title>--文本输入区域提交按钮的标签。

<description>--文本输入区域的描述。

<name>--文本输入区域中文本对象的名称。

<link>--处理文本输入请求的CGI脚本的URL链接地址。

使用<textInput>元素的目的看起来有些神秘。你可以用它提供一个搜索引擎输入框，或让读者提供反馈信息。许多聚合器忽略该元素。

<item>的元素

一个频道可以包含许多<item>元素。一个项目可以代表一个"故事" ——比如说一份报纸或杂志上的故事；如果是这样的话，那么项目的描述则是故事的摘要，项目的链接则指向整个故事的链接位置。一个项目也可以本身是完整的，如果是这样的话，项目的描述就包含了文本(整体以HTML格式编码是可以的；参见 例子)，而链接和标题可以省略。项目的所有元素都是可选的，但是至少要包含一个标题(title)或描述(description)。

01.●　title
名称：title
描述：item的标题。
例子：Venice Film Festival Tries to Quit Sinking

02.●　link
名称：link
描述：item的URL链接地址。
例子：http://nytimes.com/2004/12/07FEST.html

03.●　description　　
名称：description　　
描述：item的摘要。
例子：Some of the most heated chatter at the Venice Film Festival this week was about the way that the arrival of the stars at the Palazzo del Cinema was being staged.

04.●　author
名称：author
描述：item作者的电子邮件地址。详见这里。
例子：。

05.●　category
名称：category
描述：包含item在一个或多个分类中。详见这里。
例子：。

06.●　comments
名称：comments
描述：与item相关的评论的URL链接地址。详见 这里。
例子：。

07.●　enclosure
名称：enclosure
描述：item附加的媒体对象。详见这里。
例子：。

08.●　guid
名称：guid
描述：可以唯一确定item身份的字符串。详见 这里。
例子：。

09.●　pubDate
名称：pubDate
描述：item发布的时间。详见 这里。
例子：。

10.●　source
名称：source
描述：rss频道来源。详见 这里。
例子：。

<item>的子元素<source>

<source>是<item>的一个可选子元素。

它的值是item所属rss频道的名称，从title衍生而来。它有一个必须包含的属性url, 该属性链接到XML序列化源。

<source url="http://www.tomalak.org/links2.xml">Tomalak's Realm</source>

该元素的作用是提高链接的声望，从而进一步推广新闻项目的源头。它可以用在聚合器的Post命令中。当从聚合器中通过一个webblog编辑工具提交一个item时，<source>应该能够被自动生成。

<item>的子元素<enclosure>

<enclosure>是<item>的一个可选子元素。

它有三个必须的属性。url属性表明enclosure的位置，length属性表明它的字节大小，而type属性则指出它的标准MIME类型。

这里的url必须为一个http url。

<enclosure url="http://www.scripting.com/mp3s/weatherReportSuite.mp3" length="12216320" type="audio/mpeg" />

它的 use-case 说明请参见这里。

<item>的子元素<category>

<category>是<item>的一个可选子元素。

它有一个可选属性domain，该属性是一个用来定义分类法的字符串。

该节点的值是一个斜杠分割的字符串，它用来表明在指定的分类法中的层次位置。处理器可以为分类的识别建立协定。以下是两个例子：

<category>Grateful Dead</category>

<category domain="http://www.fool.com/cusips">MSFT</category>

你可以根据需要为不同的域包含很多<category>元素，并且可以在相同域的不同部分拥有一个交叉引用的item。

<item>的子元素<pubDate>

<pubDate> 是<item>的一个可选子元素。

它的值是一个 日期, 表明项目发布的时间。如果它是一个将来的日期，则聚合器在日期到达之前可以选择不显示该项目。

<pubDate>Sun, 19 May 2002 15:21:36 GMT</pubDate>

<item>的子元素<guid>

<guid>是<item>的一个可选子元素。

guid 是 globally unique identifier的缩写。它是一个可以唯一识别这个<item>的字符串。在发布之后，聚合器可以选择使用该字符串判断这个<item>是否是新的。

<guid>http://some.server.com/weblogItem3207</guid>

guid没有特定的语法规则。聚合器必须将它们当作一个字符串来处理。生成具有唯一性的字符串guid取决于种子的源头。

如果guid元素有isPermaLink属性，并且值为真，解释器就会认为它是item的permalink。permalink是一个可在web浏览器中打开的url链接，它指向<item>节点所描述的完整item。 例如：

<guid isPermaLink="true">http://inessential.com/2002/09/01.php#a2</guid>

isPermaLink是可选属性，默认值为真。如果值为假，guid将不会被认为是一个url或指向任何对象的url。

<item>的子元素<comments>

<comments>是<item>的一个可选子元素。

如果出现，它指向与item相关的评论的url。

<comments>http://ekzemplo.com/entry/4403/comments</comments>

更多信息，请参阅 这里。

<item>的子元素<author>

<author>是<item>的一个可选子元素。

它是item作者的电子邮件地址l。对于通过rss传播的报纸和杂志，作者可能是写该item所描述的文章的人。对于聚集型webblogs，作者可能不是责任编辑或站长。对于个人维护的webblog，忽略<author>节点是有意义的。

<author>lawyer@boyer.net (Lawyer Boyer)</author>

注释

RSS限制<link> 和 <url>元素的数据首字母为非空格字符。这些元素的数据必须以IANA-registered URI方案规定的格式开始，如http://, https://, news://, mailto:和 ftp://等。在RSS2.0规范之前，RSS规范只允许http:// 和 ftp://，然而在实践中，其他的URI方案被内容开发者广泛使用，并被聚合器所支持。聚合器也许对它们支持的URI方案有一些限制，而内容开发者不应该假定所有的聚合器都支持所有的URI方案。

在 RSS 0.91规范中，各种元素都被限制为500或100个字符。在一个符合0.91规范的频道中，不能超过15个 <item> 元素。在RSS 0.92和以后的规范中，不再有这些字符长度或者XML级别的限制。处理器也许强加一些它们自己的限制，产生者也许有自己的一些参数选择，它们可以规定在一个频道中，不超过一定数目的<item>元素，或者字符串都限制在一定的长度。

如上所述，在 RSS 2.0规范中，对于一个目录系统，当链接一个频道到它的标识中时，使用基于频道级别的分类特征。 例如，如果链接一个频道到它的Syndic8 标识，则将包括一个分类元素作为频道的子元素，它有域“Syndic8”属性，同时在Syndic8 数据库中为你的频道确定这个标识。正确的分类元素脚本应该是 <category domain="Syndic8">1765</category>。

一个经常被问到的问题是关于<guid> 如何和 <link>进行区别。它们指的是相同的事情吗？在一些内容系统中是，但在别的内容系统中可能不是。在一些系统中，<link>是一个网络日志项的永久链接。然后在别的系统中，每一个<item>都是一个较长文章的摘要，<link>指向这篇文章，而<guid>则是这个网络日志入口的永久链接。在所有的情况下，建议提供<guid>,如果可能的话，并使它成为一个永久链接。这使聚合着在内容发生变化时，也不会出现重复项目成为可能。

如果你对RSS 2.0规范的格式有任何问题，请向由Sjoerd Visscher维护的电子邮件列表RSS2-Support发送邮件。这个邮件列表不是一个技术辩论的列表，而是一个针对作者和开发人员在创建和使用RSS 2.0格式的内容时提供技术支持的列表。

RSS的扩展

RSS起源于1999年，目标是成为一个简单、易于理解的数据格式。在它逐渐成为一种流行格式之后，开发者想在一个名字空间中使用模块对它进行扩展，正像W3C定义的那样。
RSS遵循简单的规则，增加了它的能力。一个RSS feed 可以包含不是在本页中描述的内容，而只是在一个名字空间中定义的那些元素。

本文档中定义的元素不是一个名字空间本省的元素，因此， RSS2.0从某种意义上来讲，和原来的版本是兼容的，即一个 0.91 或者 0.92 版本的文件也是一个有效的 2.0 版本文件。如果RSS2.0的元素是在一个名字空间中，那么这种约束将被打破，即 一个0.9x 版本的文件不可能是一个有效的2.0 版本的文件。

发展方向

RSS决不是一个完美的格式，但是它现在已经非常流行，并得到广泛的支持。要成为一个固定的规范，RSS需要很长的一段时间。这项工作的目的是帮助RSS成为一个固定的事情，同时促进和培育围绕它进行的开发的市场的增长，并为新的聚合格式铺平道路。因此，为了实用的目的，RSS规范将被冻结在2.0.2版本。我们可以预期的可能的2.0.2 或者 2.0.3等版本，都只是出于澄清规范的目的，而不是在格式上增加新的特征。后续的工作应该集中在模块化、名字空间的使用和在完全新的聚合格式中用新的名字等方面。

许可协议和作者

RSS 2.0 是在遵循i the Attribution/Share Alike Creative Commons 许可协议 的基础上由 the Berkman Center for Internet & Society at Harvard Law School 提供。本文档的作者是 Dave Winer，UserLand software的创始人，也是 Berkman Center 的员工

下面先介绍上传文件到服务器（多文件上传）：

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;
import java.util.regex.*;
import org.apache.commons.fileupload.*;

public class upload extends HttpServlet {
  private static final String CONTENT_TYPE = "text/html; charset=GB2312";
  //Process the HTTP Post request
  public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    response.setContentType(CONTENT_TYPE);
    PrintWriter out=response.getWriter();
    try {
    DiskFileUpload fu = new DiskFileUpload();
 // 设置允许用户上传文件大小,单位:字节，这里设为2m
 fu.setSizeMax(2*1024*1024);
 // 设置最多只允许在内存中存储的数据,单位:字节
 fu.setSizeThreshold(4096);
 // 设置一旦文件大小超过getSizeThreshold()的值时数据存放在硬盘的目录
 fu.setRepositoryPath("c:\\windows\\temp");
 //开始读取上传信息
 List fileItems = fu.parseRequest(request);
 // 依次处理每个上传的文件
   Iterator iter = fileItems.iterator();

//正则匹配，过滤路径取文件名
   String regExp=".+\\\\(.+)$";

//过滤掉的文件类型
String[] errorType={".exe",".com",".cgi",".asp"};
   Pattern p = Pattern.compile(regExp);
      while (iter.hasNext()) {
       FileItem item = (FileItem)iter.next();
       //忽略其他不是文件域的所有表单信息
       if (!item.isFormField()) {
           String name = item.getName();
           long size = item.getSize();
           if((name==null||name.equals("")) && size==0)
               continue;
        Matcher m = p.matcher(name);
       boolean result = m.find();
       if (result){
           for (int temp=0;temp           if (m.group(1).endsWith(errorType[temp])){
                 throw new IOException(name+": wrong type");
           }
           }
           try{

//保存上传的文件到指定的目录

//在下文中上传文件至数据库时，将对这里改写
             item.write(new File("d:\\" + m.group(1)));

           out.print(name+"  "+size+"
");
           }
           catch(Exception e){
             out.println(e);
           }

        }
       else
       {
         throw new IOException("fail to upload");
       }
       }
   }
}
 catch (IOException e){
   out.println(e);
 }
 catch (FileUploadException e){
      out.println(e);
 }
 
  }
}

现在介绍上传文件到服务器，下面只写出相关代码：

以sql2000为例，表结构如下：

字段名：name    filecode

类型： varchar     image

数据库插入代码为：PreparedStatement pstmt=conn.prepareStatement("insert into test values(?,?)");

代码如下：

。。。。。。

           try{
             //item.write(new File("d:\\" + m.group(1)));//这段代码如果不去掉，将一同写入到服务器中

             int byteread=0;

             InputStream inStream=item.getInputStream();  //读取输入流，也就是上传的文件内容
             pstmt.setString(1,m.group(1));
             pstmt.setBinaryStream(2,inStream,(int)size);
             pstmt.executeUpdate();
             inStream.close();

             out.println(name+"  "+size+"
");
           }

。。。。。。

这样就实现了上传文件至数据库

感谢引自：http://java.mblogger.cn/zhangpoo/archive/06012005.aspx

1、从命令行建立工具数据库，打开DB2的命令窗口输入：

db2 create tools catalog cc create new database toolsdb

2、使用工具建立工具数据库，从控制中心选择Tools=>Tools Settings=>Scheduler Settings

参考文件：

DB2信息中心

http://publib.boulder.ibm.com/infocenter/db2help/index.jsp?topic=/com.ibm.db2.udb.doc/core/r0008881.htm

Biztalk 2004 以下简称为 Biztalk，WebSphere Business Integration Server Foundation 5.1 简称 WBI-SF。

1、对于关键标准的支持

由于 WebServices 技术成为将来 EAI、B2Bi 方案使用的一种主流技术，两个平台在此方面的支持均比较完善，可以在流程中很方便地调用 Web Service。

但对于 Web Service 的一个重要协议：BPEL4WS --- 商业流程执行语言，两者支持的力度则不同。WebSphere 的流程编排（Choreograph）是以 BPEL4WS 为基础，增加了一定扩展。而 Biztalk 则更象是延用了 XLANG 的流程编排（Orchestration），而做了一些扩展以便能够支持 BPEL4WS。

这个也可能与产品的发布日期有关，Biztalk 2004 在研发中的时候，BPEL 1.1 的标准还没未成形，而 WBI-SF 则是在 BPEL 1.1 成为正式标准之后才发布的。

2、应用接口与适配器（Adapter）

Biztalk 似乎在这个方面要具有优势，这可能归功于 Biztalk 产品历史稍长，很早就有 Biztalk Framework、Adapter Framework，加上近几年的不断发展，已经可以支持所有主流数据库、基础架构和产品（如 CORBA、EJB、MQ、EDI）、垂直行业标准（HIPAA,RosettaNet、FIX, SWIFT (Financial)），应用程序（Sibel CRM、SAP、J.D.Edwards、PeopleSoft），数量达到数百个，而 WBI-SF 则除了与自己的产品/技术（如CICS、Lotus等）具有接口外，其它的 Adapter 并不多。

3、开发难易程度

Biztalk 的开发并不是很容易的事情，需要了解端口、管道等诸多易另人混淆的东西，而且基本上是基于 XML 消息的处理，所以在流程的各个部分要经常做消息类型定义，消息转换等。而 WBI-SF 中则更多是使用容易理解的变量的概念，类似于函数中的参数。两者各有优缺点，基于变量（参数）易理解、容易开发，而基于消息较适合于完整的商业文档转换、交换，并且能证可以保证其中数据的安全性。

在流程活动基本元素（如循环、分支、顺序执行等）方面，Biztalk 支持较为完善，而 WBI-SF 则只是在 BPEL4WS 的基本元素基础上加入了有限扩展，不够丰富。

在文档转换与映射（Maping）方面，Biztalk 提供了完备的设计界面和转换函数，而 WBI-SF 只是提供了基本的映射功能。

4、开发工具支持

Microsoft 使用扩展后的 Visual Stuidio .NET 2003 做为 Biztalk 应用的开发工具，IBM 则紧紧围绕 Ecipse ，提供了一个类似于 WSAD 的 WebSphere Application Developer for Integration Edition（简称 WSAD-IE）来对 WBI-SF 应用开发提供支持。

就个人体会来说，在 WSAD-IE 中开发应用要比 VS.NET 中方便一些，目前在 VS.NET 中开发 Biztalk 应用还是很麻烦，需要安装 Biztalk 开发版，开发工具中不支持调试，只能通过另外的一个工具来跟踪调试。

在 WSAD-IE 中自带有一个 WBI-SF 简化版，所以不用另外安装 WBI-SF ，而且可以直接在开发工具中进行流程调试，如设置断点、单步执行等。

5、性能与效率

从理论上来说，Biztalk 的所有消息都要存储到消息数据库后再进行进一步处理，而 WBI-SF 则将商业流程分为两类：没有人工参与的流程的短流程以及有人工参与的长流程（类似于传统意义上的工作流），对于前者只在内存中进行处理，对于后者，则要存储到数据库中后再进行处理。

很难说两者那个的效率更好，Biztalk 都存储在数据库中，异步处理，很少会发生资源争用、死锁的情况，而且可靠性很高，而如果在内存中处理，并发量较小的时候可能会较快，但并发量大的时候，很可能会产生资源争用，进而死锁降低系统效率。

就开发工具来说，WSAD-IE 继承了 WSAD 奇慢的速度，在 1G 的 Vmware Virtual Machine 中花了 1 分钟时间才启动完成，编译部署时间也很长，在这方面，其与 Biztalk 和 VS.NET 的速度差异不是一两倍，简直是糟蹋了 Eclipse。

6、人力工作流支持

人力工作流（Human Workflow）主要指商业流程中需要人力参与，如审批、复核等。在 WBI-SF 中对人力工作流有一定的支持，每个活动结点可以设置其类型为 staff activities ，然后可以设置操作用户、权限等，且有内建的、简单的 Web 操作界面来完成在流程上定义的操作。

IBM 对于人力工作流更完整的支持体现在 WebSphere Interchange Server 4 （购自 CrossWorlds ）中，估计这个东西以后会和 WBI-SF 进行整合。

Biztalk 本身的工作流特性较弱，只是提供了一些工作流基础（基础服务和接口等），具体的实现需要较多的二次开发，结合 SharePoint Services 和 InfoPath 等完成。

7、建模工具

Microsoft 提供了一个基于 Visio 的插件，可以由业务人员绘制商业处理流程图，并可以导入到 VS.NET 中直接作为 Biztalk Orchestration 基本框架来使用。

IBM 有一个名为 WebSphere Business Integration Modeler 的单独的建模工具，不知道是否是提供 WBI-SF 来使用的，此建模工具也构建在 Eclipse 的基础上。

8、其它相关信息

虽然大家说 Biztalk 与 Infopath 的关系有如 Outlook 和 Exchange ，但在实际应用中，Infopath 要想利用 Biztalk 的功能，远不如 Outlook 配置一个 Profile 就可以使用 MailBox 和 Public Folder 那样简单。

Biztalk 仍需要在 BPEL4WS、Human Workflow、开发支持等方面继续进步。

IBM 在整合方面的工具很多，如 WebSphere Business Integration（不知道其与 WBI-SF 的关系如何，个人以为 WBI-SF 是 WBI 的升级版本）、WBI MessageBroker、WBI Modeler、WBI Adapter Framework、WebSphere Interchange Server、WebSphere MQ Workflow、MQ Integrator 等，说实话，这么多东西，实在很让人 Confuse ，即然天天对外宣称口号：整合应用（ IBM 开发大会口号），何不把自己的整合产品先好好整合一下？或者至少给用户一个明确的产品发展计划以便于产品或技术选型/决策呀。

http://sourceforge.net/projects/xlsjdbc/

http://sourceforge.net/projects/csvjdbc

java.net http://www.java.net

www.eclipse.org

www.opensource.org

Lomboz http://www.objectlearn.com/index.jsp (J2EE plugin for Eclipse)
htmlArea http://sourceforge.net/projects/itools-htmlarea/ (所见即所得的在线HTML编辑器)
XmlBuddy http://www.xmlbuddy.com/ (XML Editor plugin for Eclipse)
JFreeChart http://www.jfree.org/ (用于生成图表的项目)
EclipseME http://eclipseme.sourceforge.net/ (J2ME Developmnt Plugin for Eclipse)
mvnForum http://sourceforge.net/projects/mvnforum/ (论坛)
jChatBox http://www.javazoom.net/index.shtml (用servlet实现的WEB聊天引擎)
POI http://jakarta.apache.org/poi/index.html (用于处理Excel,WORD等文档的项目)
FileUpload http://jakarta.apache.org/commons/fileupload/ (用于处理HTTP文件上传得项目)
PDFBox http://sourceforge.net/projects/pdfbox/ (处理PDF文档的项目)
Lucene http://jakarta.apache.org/lucene/index.html (搜索引擎)
Digester http://jakarta.apache.org/commons/digester/ (处理XML信息的项目)
DBCP http://jakarta.apache.org/commons/dbcp/ (数据库连接池)
AXIS http://ws.apache.org/axis/ (WebService 的实现框架)
Jetspeed http://portals.apache.org/jetspeed-1/ (Portal)
HSQLDB http://sourceforge.net/projects/hsqldb/ (Im memory Database Engine)
CEWOLF http://sourceforge.net/projects/cewolf/ (一套标签库实现Web报表,使用的是jFreeChart引擎)
Struts Menu http://sourceforge.net/projects/struts-menu/ (基于Struts的Web菜单项目)
htmlparser http://sourceforge.net/projects/htmlparser/ (用于解析HTML信息的项目)
Mondrian http://sourceforge.net/projects/mondrian/(Open Source OLAP Database)
ProGuard http://sourceforge.net/projects/proguard/(Java的混淆器)
InfoGlue http://sourceforge.net/projects/infoglue/ (J2EE 内容管理系统)
JPivot http://sourceforge.net/projects/jpivot/ (基于WEB的OLAP 展现)
http://java-source.net/

(5)几个常用JAVA开源项目的地址荟萃:
Lomboz      http://www.objectlearn.com/index.jsp (J2EE plugin for Eclipse)
htmlArea    http://sourceforge.net/projects/itools-htmlarea/ (所见即所得的在线HTML

编辑器)
XmlBuddy   http://www.xmlbuddy.com/ (XML Editor plugin for Eclipse)
JFreeChart http://www.jfree.org/ (用于生成图表的项目)
EclipseME   http://eclipseme.sourceforge.net/ (J2ME Developmnt Plugin for Eclipse)
mvnForum  http://sourceforge.net/projects/mvnforum/ (论坛)
jChatBox    http://www.javazoom.net/index.shtml (用servlet实现的WEB聊天引擎)
POI            http://jakarta.apache.org/poi/index.html (用于处理Excel,WORD等文档

的项目)
FileUpload http://jakarta.apache.org/commons/fileupload/ (用于处理HTTP文件上传得项

目)
PDFBox      http://sourceforge.net/projects/pdfbox/ (处理PDF文档的项目)
Lucene      http://jakarta.apache.org/lucene/index.html (搜索引擎)
Digester    http://jakarta.apache.org/commons/digester/ (处理XML信息的项目)
DBCP         http://jakarta.apache.org/commons/dbcp/  (数据库连接池)
AXIS          http://ws.apache.org/axis/ (WebService 的实现框架)
Jetspeed   http://portals.apache.org/jetspeed-1/ (Portal)
HSQLDB    http://sourceforge.net/projects/hsqldb/ (Im memory Database Engine)
CEWOLF   http://sourceforge.net/projects/cewolf/ 

(一套标签库实现Web报表,使用的是jFreeChart引擎)
Struts Menu http://sourceforge.net/projects/struts-menu/  (基于Struts的Web菜单项目

)
htmlparser   http://sourceforge.net/projects/htmlparser/   (用于解析HTML信息的项目

)
Mondrian     http://sourceforge.net/projects/mondrian/  (Open Source OLAP

Database)
ProGuard     http://sourceforge.net/projects/proguard/ (Java的混淆器)
InfoGlue      http://sourceforge.net/projects/infoglue/  (J2EE 内容管理系统)
JPivot          http://sourceforge.net/projects/jpivot/  (基于WEB的OLAP 展现)
HttpClient   http://jakarta.apache.org/commons/httpclient/  处理http客户端的接口

这篇文章是在我发表过的<计算Java时间>(译者:已经翻译完成)的基础上的。在这里，我列出那篇文章几个你应该熟悉得关键点。如果这几点你不太清楚，我建议你读一下<计算Java时间>，了解一下。
1. Java计算时间依靠1970年1月1日开始的毫秒数.                                                                                                                                                              
2. Date类的构造函数Date()返回代表当前创建的时刻的对象。Date的方法getTime()返回一个long值在数值上等于1970年1月1日之前或之后的时刻。
3. DateFormat类用来转换Date到String,反之亦然。静态方法getDateInstance()返回DateFormat的缺省格式；getDateInstance(DateFormat.FIELD)返回指定的DateFormat对象格式。Format(Date d)方法返回String表示日期，例如＂January 1,2002.＂反过来，parse(String s)方法返回以参数字符串表示的Date对象。
4. format()方法返回的字符串格式根据不同地区的时间设置而有所不同。
5. GregorianCalendear类有两个重要的构造函数：GregorianCalerdar(),返回代表当前创建时间的对象；GregorianCalendar(int year,int month,int date)返回代表任意日期的对象。GregorianCalendar类的getTime()方法返回日期对象。Add(int field,int amount)方法通过加或减时间单位，象天数，月数或年数来计算日期。
GregorianCalendar和 时间
 两个GregorianCalendar的构造函数可以用来处理时间。前者创建一个表示日期，小时和分钟的对象：

GregorianCalendar(int year, int month, int date, int hour, int minute)

第二个创建一个表示一个日期，小时，分钟和秒：

GregorianCalendar(int year, int month, int date, int hour, int minute, int second)

首先，我应该提醒一下，每一个构造函数需要时间信息中的日期信息(年，月，日)。如果你想说2:30 p.m.,你必须指出日期。
同样，每一个GregorianCalendar构造函数创建一个在时间上使用毫秒计算的对象。所以，如果你的构造函数只提供年，月，日参数，那小时，分钟，秒和毫秒的值将被置0.
DateFormat和时间
你可以使用静态方法getDateTimeInstance(int dateStyle,int timeStyle)来建立DateFormat对象来显示时间和日期。这个方法表明你想要的日期和时间格式。如果你喜欢使用缺省格式，可以使用getDateTimeInstance()来代替它。
你可以使用静态方法getTimeInstance(int timeStyle)创建DateFormat对象来显示正确的时间。
下面的程序示范了getDateTimeInstance()和getTimeInstance()怎样工作：

import java.util.*;
import java.text.*;

public class Apollo {
   public static void main(String[] args) {
      GregorianCalendar liftOffApollo11 = new GregorianCalendar(1969, Calendar.JULY, 16, 9, 32);
      Date d = liftOffApollo11.getTime();
      DateFormat df1 = DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM);
      DateFormat df2 = DateFormat.getTimeInstance(DateFormat.SHORT);
      String s1 = df1.format(d);
      String s2 = df2.format(d);
      System.out.println(s1);
      System.out.println(s2);
   }
}  
       
在我的电脑上，上面的程序显示如下：

Jul 16, 1969 9:32:00 AM
9:32 AM
(输出根据你所在得地区有所不同)

计算时间间隔
     你可能有时需要计算过去的时间；例如，给你开始和结束时间，你想知道制造流程的持续时间。一个出租公司按小时或天数出租东西，计算时间对他们也很有用。同样的，在金融界，经常需要计算重要的支付时间。
将问题复杂化，人类至少是用两种方法计算时间。你可以说一天已经结束当24小时过去了，或者日历从今天翻到明天。我们将讨论我们想到的这两种情况。
时间段，情况 1：严格时间单位
在这种情况中，只有24小时过去，这天才过去，60分钟过去，这个小时才过去，60秒过去，这个分钟才过去，以此类推。在这个方法中，23小时的时间将被认为是0天。
使用这种方法计算时间段，你从计算过去的毫秒开始。为了做到这一点，首先转换每个日期为从1970年1月1日起得毫秒数。你可以从第二个毫秒值中减去第一个毫秒值。这里有一个简单的计算：

import java.util.*;

public class ElapsedMillis {
   public static void main(String[] args) {
      GregorianCalendar gc1 = new GregorianCalendar(1995, 11, 1, 3, 2, 1);
      GregorianCalendar gc2 = new GregorianCalendar(1995, 11, 1, 3, 2, 2);
      // the above two dates are one second apart
      Date d1 = gc1.getTime();
      Date d2 = gc2.getTime();
      long l1 = d1.getTime();
      long l2 = d2.getTime();
      long difference = l2 - l1;
      System.out.println("Elapsed milliseconds: " + difference);
   }
}    

上面的程序打印如下：

Elapsed milliseconds: 1000

这个程序也带来一点混淆。GregorianCalendar类的getTime()返回一个Date对象，Date类的getTime()方法返回从1970年1月1日到这个时间的long类型的毫秒数值。虽然他们的方法名字相同，返回值却不一样！
下面的程序片断用简单的整数除法转换毫秒到秒：

long milliseconds = 1999;
long seconds = 1999 / 1000;

这种方法舍去小数部分转换毫秒到秒，所以1,999毫秒等于1秒，2,000毫秒等于2秒。
计算更大的单位-例如天数，小时和分钟-给定一个时间数值，可以使用下面的过程：
1. 计算最大的单位，减去这个数值的秒数
2. 计算第二大单位，减去这个数值的秒数
3. 重复操作直到只剩下秒
例如,如果你的时间的10,000秒，你想知道这个数值相应的是多少小时，多少分钟，多少秒，你从最大的单位开始：小时。10,000除以3600（一个小时的秒数）得到小时数。使用整数除法，答案是2小时（整数除法中小数舍去）计算剩下的秒数，10,000-(3,600 x 2) = 2,800秒。所以你有2小时和2,800秒。
将2,800秒转换成分钟，2,800除以60。使用整数除法，答案是46。2,800 - (60 x 46) = 40秒。最后答案是2小时，46分，40秒。
下面的Java程序使用上面的计算方法：

import java.util.*;

public class Elapsed1 {
   public void calcHMS(int timeInSeconds) {
      int hours, minutes, seconds;
      hours = timeInSeconds / 3600;
      timeInSeconds = timeInSeconds - (hours * 3600);
      minutes = timeInSeconds / 60;
      timeInSeconds = timeInSeconds - (minutes * 60);
      seconds = timeInSeconds;
      System.out.println(hours + " hour(s) " + minutes + " minute(s) " + seconds + " second(s)");
   }

   public static void main(String[] args) {
      Elapsed1 elap = new Elapsed1();
      elap.calcHMS(10000);
   }
} 

输出结果如下：

2 hour(s) 46 minute(s) 40 second(s)

上面的程序甚至在时间少于一个小时也可以正确的计算小时数。例如，你用上面的程序计算1,000秒，输出入下：
0 hour(s) 16 minute(s) 40 second(s)
举一个现实世界的例子，下面的程序计算阿波罗11飞到月球使用得时间：

import java.util.*;

public class LunarLanding {

   public long getElapsedSeconds(GregorianCalendar gc1, GregorianCalendar gc2) {
      Date d1 = gc1.getTime();
      Date d2 = gc2.getTime();
      long l1 = d1.getTime();
      long l2 = d2.getTime();
      long difference = Math.abs(l2 - l1);
      return difference / 1000;
   }

   public void calcHM(long timeInSeconds) {
      long hours, minutes, seconds;
      hours = timeInSeconds / 3600;
      timeInSeconds = timeInSeconds - (hours * 3600);
      minutes = timeInSeconds / 60;
      System.out.println(hours + " hour(s) " + minutes + " minute(s)" );
   }

   public static void main(String[] args) {
      GregorianCalendar lunarLanding = new GregorianCalendar(1969, Calendar.JULY, 20, 16, 17);
      GregorianCalendar lunarDeparture = new GregorianCalendar(1969, Calendar.JULY, 21, 13, 54);
      GregorianCalendar startEVA = new GregorianCalendar(1969, Calendar.JULY, 20, 22, 56);
      GregorianCalendar endEVA = new GregorianCalendar(1969, Calendar.JULY, 21, 1, 9);

      LunarLanding apollo = new LunarLanding();

      long eva = apollo.getElapsedSeconds(startEVA, endEVA);
      System.out.print("EVA duration = ");
      apollo.calcHM(eva);

      long lunarStay = apollo.getElapsedSeconds(lunarLanding, lunarDeparture);
      System.out.print("Lunar stay = ");
      apollo.calcHM(lunarStay);
   }
}         

上面程序输出如下：

EVA duration = 2 hour(s) 13 minute(s)
Lunar stay = 21 hour(s) 37 minute(s)

目前为止，我们计算的基础公式是这样的：1分钟=60秒，1小时=60分，1天=24小时。
"1个月=？天，1年=？天"怎么办？
月份的天数有28，29，30，31；一年可以是365或366天。因此，当你试图计算严格单位的月份和年时，问题就产生了。例如，如果你使用月份的平均天数（近似30.4375），并且计算下面的时间间隔:

* July 1, 2:00 a.m. to July 31, 10:00 p.m.
* February 1, 2:00 a.m. to February 29, 10:00 p.m.

第一个计算结果是1个月；第二个结果是0个月！
所以，在计算严格单位时间的月份和年份是要想好。
时间段，情况 2:时间单位变化
时间单位的变化相当的简单：如果你要统计天数，你可以简单的统计日期变化次数。例如，如果某事15日开始，17日结束，经过2天。（日期先是便到16，再到17）同样的，一个步骤下午3：25开始，4：10 p.m结束，历时1个小时，因为小时数值变了一次（从3到4）。
图书馆经常使用这种习惯计算时间。例如，如果你从图书馆接一本书，我不能占有这本书最少24小时，会认为图书馆这样才给你算一天。而是，我的账号上记录我借书的日期。日期以变成下一天，我就已经结这本书一天了，即使总计不足24小时。
当使用单位的变化来计算时间段，通常感觉计算的时间没有多于一个时间单位。例如，如果9:00 p.m.我借了一本图书馆的书，第二天中午还回去，我能算出我借了这本书一天了。可是，有一种感觉在问："1天和几个小时呢？"这本说总计借出15个小时，答案是一天还差9个小时呢？因此，这篇文章里，我将以一个时间单位变化计算时间。
单位变化的时间算法
 这是你怎样计算两个日期的时间变化：
1. 制作两个日期的拷贝。Close()方法能制作拷贝。
2. 使用日期拷贝，将所有的小于时间单位变化的部分设置成它的最小单位。例如，如果计算天数，那么将小时，分钟，秒和毫秒设置成0。这种情况中，使用clear()方法将时间值设置称他们各自的最小值。
3. 取出较早的日期，将你要计算的单位加1，重复直到两个日期相等。你加1的次数就是答案。可以使用before()和after()方法，他们返回boolean值，来判断是否一个日期在另一个日期之前或之后。
下面的类的方法用来计算天数和月数。

import java.util.*;

public class ElapsedTime {

   public int getDays(GregorianCalendar g1, GregorianCalendar g2) {
      int elapsed = 0;
      GregorianCalendar gc1, gc2;

      if (g2.after(g1)) {
         gc2 = (GregorianCalendar) g2.clone();
         gc1 = (GregorianCalendar) g1.clone();
      }
      else   {
         gc2 = (GregorianCalendar) g1.clone();
         gc1 = (GregorianCalendar) g2.clone();
      }

      gc1.clear(Calendar.MILLISECOND);
      gc1.clear(Calendar.SECOND);
      gc1.clear(Calendar.MINUTE);
      gc1.clear(Calendar.HOUR_OF_DAY);

      gc2.clear(Calendar.MILLISECOND);
      gc2.clear(Calendar.SECOND);
      gc2.clear(Calendar.MINUTE);
      gc2.clear(Calendar.HOUR_OF_DAY);

      while ( gc1.before(gc2) ) {
         gc1.add(Calendar.DATE, 1);
         elapsed++;
      }
      return elapsed;
   }

   public int getMonths(GregorianCalendar g1, GregorianCalendar g2) {
      int elapsed = 0;
      GregorianCalendar gc1, gc2;

      if (g2.after(g1)) {
         gc2 = (GregorianCalendar) g2.clone();
         gc1 = (GregorianCalendar) g1.clone();
      }
      else   {
         gc2 = (GregorianCalendar) g1.clone();
         gc1 = (GregorianCalendar) g2.clone();
      }

      gc1.clear(Calendar.MILLISECOND);
      gc1.clear(Calendar.SECOND);
      gc1.clear(Calendar.MINUTE);
      gc1.clear(Calendar.HOUR_OF_DAY);
      gc1.clear(Calendar.DATE);

      gc2.clear(Calendar.MILLISECOND);
      gc2.clear(Calendar.SECOND);
      gc2.clear(Calendar.MINUTE);
      gc2.clear(Calendar.HOUR_OF_DAY);
      gc2.clear(Calendar.DATE);

      while ( gc1.before(gc2) ) {
         gc1.add(Calendar.MONTH, 1);
         elapsed++;
      }
      return elapsed;
   }
}

你可以在上面的类中补充另外的方法来处理小时和分钟。同样，计算时间段的算法能更高效一些，尤其是时间相隔很长。可是，作为介绍目的，这个算法有短小和简单的优势。
下面的例子使用ElapsedTime类来计算两个日期之间的天使，而后是月数：

import java.util.*;

public class Example {
   public static void main(String[] args) {
      GregorianCalendar gc1 = new GregorianCalendar(2001, Calendar.DECEMBER, 30);
      GregorianCalendar gc2 = new GregorianCalendar(2002, Calendar.FEBRUARY, 1);

      ElapsedTime et = new ElapsedTime();
      int days = et.getDays(gc1, gc2);
      int months = et.getMonths(gc1, gc2);

      System.out.println("Days = " + days);
      System.out.println("Months = " + months);
   }
}

当计算时，上面的程序可能有用，例如，最近的航班。它显示下面的输出：

Days = 33
Months = 2

(OK,关于航班的计算有些夸张；这个天数算法很适合像图书馆借书这样的应用，你看到了她怎样工作)
告诫
在进行时间工作时要谨慎：你看到的时间段的例子，你精确仔细的考虑非常重要。本文介绍了两种通常计算时间段的想法，但是人们能想到的时间段的计算方法仅仅受到人类想象力的限制。
所以，当写一个Java程序的时候，确信你的精确度能让使用和以来这些程序的人满意。同样，彻底的测试程序对处理时间的程序非重重要。
总结
本文是在我的前一篇文章 Java时间计算介绍怎样使用GregorianCalendar 和 DateFormat类处理时间问题的基础上的。你已经看到了两种方法来思考时间段问题和两种相应的途径使用Java来处理时间问题。这里提供的信息，很基础，提供给你一个在Java中处理时间问题的有力工具。

关于作者
 Robert Nielsen是SCJP。他拥有硕士学位，专攻计算机教育，并且在计算机领域执教多年。他也在各样的杂志上发表过很多计算机相关的文章。
关于译者
Cocia Lin(cocia@163.com)是程序员。它拥有学士学位，现在专攻Java相关技术，刚刚开始在计算机领域折腾。

    Java统计从1970年1月1日起的毫秒的数量表示日期。也就是说，例如，1970年1月2日，是在1月1日后的86，400，000毫秒。同样的，1969年12月31日是在1970年1月1日前86，400，000毫秒。Java的Date类使用long类型纪录这些毫秒值.因为long是有符号整数，所以日期可以在1970年1月1日之前，也可以在这之后。Long类型表示的最大正值和最大负值可以轻松的表示290，000，000年的时间，这适合大多数人的时间要求。
Date 类
   Date类可以在java.util包中找到，用一个long类型的值表示一个指定的时刻。它的一个有用的构造函数是Date(),它创建一个表示创建时刻的对象。getTime()方法返回Date对象的long值。在下面的程序中，我使用Date()构造函数创建一个表示程序运行时刻的对象，并且利用getTime()方法找到这个日期代表的毫秒数量：

import java.util.*;

public class Now {
   public static void main(String[] args) {
      Date now = new Date();
      long nowLong = now.getTime();
      System.out.println("Value is " + nowLong);
   }
}

当我运行这个程序后，我得到972,568,255,150.快速确认一下这个数字，起码在一个合理的范围：它不到31年，这个数值相对1970年1月1日到我写这篇文章的时间来说，是合理的。计算机是这个毫秒值表示时间，人们可不愿意说" 我将在996,321,998,34见到你。"幸运的是，Java提供了一个转换Date对象到字符串的途径，表示成传统的形式。我们在下一节讨论DateFormat类，它直观的建立日期字符串。
DateFormat类
 DateFormat类的一个目标是建立一个人们能够识别的字符串。然而，因为语言的差别，不是所有的人希望看到严格的相同格式的日期。法国人更喜欢看到"25 decembre 2000,",但是美国人习惯看到"December 25,2000."所以一个DateFormat的实例创建以后，这个对象包含了日期的显示格式的信息。如果使用用户电脑区域设置缺省的格式，你可以象下面那样，创建DateFormat对象，使用getDateInstance()方法：

DateFormat df = DateFormat.getDateInstance();  

DateFormat类在java.text包中可以找到。
转换成字符串
你可以使用format()方法转换Date对象为一个字符串。下面的示例程序说明了这个问题：

import java.util.*;
import java.text.*;

public class NowString {
   public static void main(String[] args) {
      Date now = new Date();
      DateFormat df = DateFormat.getDateInstance();
      String s = df.format(now);
      System.out.println("Today is " + s);
   }
} 

在上面的代码中，展示了没有参数，使用缺省格式的getDateInstance()方法。Java还提供了几个选择日期格式，你可以通过使用重载的getDateInstance(int style)获得。出于方便的原因，DateFormat提供了几种预置的常量，你可以使用这些常量参数。下面是几个SHORT, MEDIUM, LONG, 和FULL类型的示例：

import java.util.*;
import java.text.*;

public class StyleDemo {
   public static void main(String[] args) {
      Date now = new Date();

      DateFormat df =  DateFormat.getDateInstance();
      DateFormat df1 = DateFormat.getDateInstance(DateFormat.SHORT);
      DateFormat df2 = DateFormat.getDateInstance(DateFormat.MEDIUM);
      DateFormat df3 = DateFormat.getDateInstance(DateFormat.LONG);
      DateFormat df4 = DateFormat.getDateInstance(DateFormat.FULL);
      String s =  df.format(now);
      String s1 = df1.format(now);
      String s2 = df2.format(now);
      String s3 = df3.format(now);
      String s4 = df4.format(now);

      System.out.println("(Default) Today is " + s);
      System.out.println("(SHORT)   Today is " + s1);
      System.out.println("(MEDIUM)  Today is " + s2);
      System.out.println("(LONG)    Today is " + s3);
      System.out.println("(FULL)    Today is " + s4);
   }
}

程序输出如下：

(Default) Today is Nov 8, 2000
(SHORT)   Today is 11/8/00
(MEDIUM)  Today is Nov 8, 2000
(LONG)    Today is November 8, 2000
(FULL)    Today is Wednesday, November 8, 2000

同样的程序，在我的电脑上使用缺省设置运行后，改变区域设置为瑞典，输出如下：

(Default) Today is 2000-nov-08
(SHORT)   Today is 2000-11-08
(MEDIUM)  Today is 2000-nov-08
(LONG)    Today is den 8 november 2000
(FULL)    Today is den 8 november 2000    
 
从这里，你能看到，瑞典的月份不是大写的（虽然November还是november）.还有，LONG和FULL版本在瑞典语中是一样的，但是美国英语却不同。另外，有趣的是，瑞典语单词的星期三,onsdag，没有包含在FULL日期里，英语却包括。
注意你能够使用getDateInstance()方法改变DateFormat实例的语种；但是，在上面的例子中，是通过改变Windows98的控制面板的区域设置做到的。不同的地方的区域设置不同，结果就不同，这样有好处，也有不足，Java程序员应该了解这些。一个好处是Java程序员可以只写一行代码就可以显示日期，而且世界不同地区的电脑运行同样的程序会有不用的日期格式。 但是这也是一个缺点，当程序员希望显示同一种格式的时--这也有可取之处，举例来说，在程序中混合输出文本和日期，如果文本是英文，我们就不希望日期格式是其他的格式，象德文或是西班牙文。如果程序员依靠日期格式编程，日期格式将根据运行程序所在电脑的区域设置不用而不同。
解析字符串
 通过parse()方法，DateFormat能够以一个字符串创立一个Date对象。这个方法能抛出ParseException异常，所以你必须使用适当的异常处理技术。下面的例子程序通过字符串创建Date对象：

import java.util.*;
import java.text.*;

public class ParseExample {
   public static void main(String[] args) {
      String ds = "November 1, 2000";
      DateFormat df = DateFormat.getDateInstance();
      try {
         Date d = df.parse(ds);
      }
      catch(ParseException e) {
         System.out.println("Unable to parse " + ds);
      }
   }
}

在创建一个任意的日期时parse()方法很有用。我将通过另一种方法创建一个任意得日期。同时，你将看到怎样进行基本日期计算，例如计算90天后的另一天。你可以使用GregorianCalendar类来完成这个任务。
GregorianCalendar类
 创建一个代表任意日期的一个途径使用GregorianCalendar类的构造函数，它包含在java.util包中：

GregorianCalendar(int year, int month, int date)

注意月份的表示，一月是0，二月是1，以此类推，是12月是11。因为大多数人习惯于使用单词而不是使用数字来表示月份，这样程序也许更易读，父类Calendar使用常量来表示月份：JANUARY, FEBRUARY,等等。所以，创建Wilbur 和 Orville制造第一架动力飞机的日期（December 17, 1903），你可以使用：

GregorianCalendar firstFlight = new GregorianCalendar(1903, Calendar.DECEMBER, 17); 
出于清楚的考虑，你应该使用前面的形式。但是，你也应该学习怎样阅读下面的短格式。下面的例子同样表示December 17,1903（记住，在短格式中，11表示December）

GregorianCalendar firstFlight = new GregorianCalendar(1903, 11, 17);  

在上一节中，你学习了转换Date对象到字符串。这里，你可以做同样的事情；但是首先，你需要将GregorianCalendar对象转换到Date。要做到这一点，你可以使用getTime()方法，从它得父类Calendar继承而来。GetTime()方法返回GregorianCalendar相应的Date对象。你能够创建GregorianCalendar对象，转换到Date对象，得到和输出相应的字符串这样一个过程。下面是例子：

import java.util.*;
import java.text.*;

public class Flight {

   public static void main(String[] args) {
      GregorianCalendar firstFlight = new GregorianCalendar(1903, Calendar.DECEMBER, 17);   
      Date d = firstFlight.getTime();
      DateFormat df = DateFormat.getDateInstance();
      String s = df.format(d);
      System.out.println("First flight was " + s);
   }
}

有时候创建一个代表当前时刻的GregorianCalendar类的实例是很有用的。你可以简单的使用没有参数的GregorianCalendar构造函数，象这样：

GregorianCalendar thisday = new GregorianCalendar();

一个输出今天日期的例子程序，使用GregorianCalendar对象：

import java.util.*;
import java.text.*;

class Today {
   public static void main(String[] args) {
      GregorianCalendar thisday = new GregorianCalendar(); 
      Date d = thisday.getTime();
      DateFormat df = DateFormat.getDateInstance();
      String s = df.format(d);
      System.out.println("Today is " + s);
   }
}

注意到，Date()构造函数和GregorianCalendar()构造函数很类似：都创建一个对象，条件简单，代表今天。
日期处理
GregorianCalendar类提供处理日期的方法。一个有用的方法是add().使用add()方法，你能够增加象年，月数，天数到日期对象中。要使用add()方法，你必须提供要增加的字段，要增加的数量。一些有用的字段是DATE, MONTH, YEAR, 和 WEEK_OF_YEAR。下面的程序使用add()方法计算未来80天的一个日期。在Jules的<环球80天>是一个重要的数字，使用这个程序可以计算Phileas Fogg从出发的那一天1872年10月2日后80天的日期：

import java.util.*;
import java.text.*;

public class World {
   public static void main(String[] args) {
      GregorianCalendar worldTour = new GregorianCalendar(1872, Calendar.OCTOBER, 2);
      worldTour.add(GregorianCalendar.DATE, 80);
      Date d = worldTour.getTime();
      DateFormat df = DateFormat.getDateInstance();
      String s = df.format(d);
      System.out.println("80 day trip will end " + s);
   }
}

这个例子是想象的，但在一个日期上增加天数是一个普遍的操作：影碟可以租3天，图书馆可以借书21天，商店经常需要将购买的物品在30天内卖出。下面的程序演示了使用年计算：

import java.util.*;
import java.text.*;

public class Mortgage {
   public static void main(String[] args) {
      GregorianCalendar mortgage = new GregorianCalendar(1997, Calendar.MAY, 18);
      mortgage.add(Calendar.YEAR, 15);
      Date d = mortgage.getTime();
      DateFormat df = DateFormat.getDateInstance();
      String s = df.format(d);
      System.out.println("15 year mortgage amortized on " + s);    }
}

    add()一个重要的副作用是它改变的原来的日期。有时候，拥有原始日期和修改后的日期很重要。不幸的是，你不能简单的创建一个GregorianCalendar对象，设置它和原来的相等（equal）。原因是两个变量指向同一个Date()对象地址。如果Date对象改变，两个变量就指向改变后的日期对象。代替这种做法，应该创建一个新对象。下面的程序示范了这种做法：

import java.util.*;
import java.text.*;

public class ThreeDates {
   public static void main(String[] args) {
      GregorianCalendar gc1 = new GregorianCalendar(2000, Calendar.JANUARY, 1);
      GregorianCalendar gc2 = gc1;
      GregorianCalendar gc3 = new GregorianCalendar(2000, Calendar.JANUARY, 1);
      //Three dates all equal to January 1, 2000

      gc1.add(Calendar.YEAR, 1);
      file://gc1 and gc2 are changed

      DateFormat df = DateFormat.getDateInstance();

      Date d1 = gc1.getTime();
      Date d2 = gc2.getTime();
      Date d3 = gc3.getTime();

      String s1 = df.format(d1);
      String s2 = df.format(d2);
      String s3 = df.format(d3);

      System.out.println("gc1 is " + s1);
      System.out.println("gc2 is " + s2);
      System.out.println("gc3 is " + s3);
   }
}

    程序运行后，gc1和gc2被变成2001年（因为两个对象指向同一个Date，而Date已经被改变了）。对象gc3指向一个单独的Date，它没有被改变。
计算复习日期
在这节，你将看到一个依据现实世界的例子。这个详细的程序计算过去一个具体的日期。例如，你阅读这篇文章，你想要记住一个印象深刻的知识点。如果你没有照片一样的记忆力，你就要定期的复习这些新资料，这将帮助你记住它。关于复习系统，Kurt Hanks 和 Gerreld L. Pulsipher在他们的< Five Secrets to Personal Productivity个人能力的5个秘密>中有讨论，建议看过第一眼后马上回顾一下，然后是1天后，1个星期后，1个月后，3个月后，1年后。我的这篇文章，你要马上回顾一下，从现在算起，再就是明天，然后是1个星期，1个月，3个月，1年后。我们的程序将计算这些日期。
这个程序非常有用的，它将是PIM(Personal Information Manager个人信息管理器)的一个组成部分，并将确定复习时间。在下面的程序中，getDates()方法对一个返回日期数组（复习日期）的电子软件很有用。另外，你可以返回单独的一个日期，使用getFirstDay(),getOneDay(),getOneWeek(),getOnMonth()和getOneYear().当时间范围超出这个PIM的ReviewDates的计算范围时ReviewDates类演示了怎样计算时间段。现在，你可以容易的修改它用来处理你需要的时间段，象图书馆借书，录影带租赁和抵押计算。首先，ReviewDates类显示在下面：

import java.util.*;
import java.text.*;

public class ReviewDates {
   private GregorianCalendar firstDay, oneDay, oneWeek, oneMonth, oneQuarter, oneYear;
   final int dateArraySize = 6;

   ReviewDates(GregorianCalendar gcDate) {
      int year = gcDate.get(GregorianCalendar.YEAR);
      int month = gcDate.get(GregorianCalendar.MONTH);
      int date = gcDate.get(GregorianCalendar.DATE);

      firstDay = new GregorianCalendar(year, month, date);
      oneDay = new GregorianCalendar(year, month, date);
      oneWeek = new GregorianCalendar(year, month, date);
      oneMonth = new GregorianCalendar(year, month, date);
      oneQuarter = new GregorianCalendar(year, month, date);
      oneYear = new GregorianCalendar(year, month, date);

      oneDay.add(GregorianCalendar.DATE, 1);
      oneWeek.add(GregorianCalendar.DATE, 7);
      oneMonth.add(GregorianCalendar.MONTH, 1);
      oneQuarter.add(GregorianCalendar.MONTH, 3);
      oneYear.add(GregorianCalendar.YEAR, 1);
   }

   ReviewDates() {
      this(new GregorianCalendar());
   }

   public void listDates() {
      DateFormat df = DateFormat.getDateInstance(DateFormat.LONG);
      Date startDate = firstDay.getTime();
      Date date1 = oneDay.getTime();
      Date date2 = oneWeek.getTime();
      Date date3 = oneMonth.getTime();
      Date date4 = oneQuarter.getTime();
      Date date5 = oneYear.getTime();

      String ss =  df.format(startDate);
      String ss1 = df.format(date1);
      String ss2 = df.format(date2);
      String ss3 = df.format(date3);
      String ss4 = df.format(date4);
      String ss5 = df.format(date5);

      System.out.println("Start date is " + ss);
      System.out.println("Following review dates are:");
      System.out.println(ss1);
      System.out.println(ss2);
      System.out.println(ss3);
      System.out.println(ss4);
      System.out.println(ss5);
      System.out.println();
   }

   public GregorianCalendar[] getDates() {
      GregorianCalendar[] memoryDates = new GregorianCalendar[dateArraySize];
      memoryDates[0] = firstDay;
      memoryDates[1] = oneDay;
      memoryDates[2] = oneWeek;
      memoryDates[3] = oneMonth;
      memoryDates[4] = oneQuarter;
      memoryDates[5] = oneYear;
      return memoryDates;
   }

   public GregorianCalendar getFirstDay() {
      return this.firstDay;
   }

   public GregorianCalendar getOneDay() {
      return this.oneDay;
   }

   public GregorianCalendar getOneWeek() {
      return this.oneWeek;
   }

   public GregorianCalendar getOneMonth() {
      return this.oneMonth;
   }

   public GregorianCalendar getOneQuarter() {
      return this.oneQuarter;
   }

   public GregorianCalendar getOneYear() {
      return this.oneYear;
   }
} 

下面是使用ReviewDates类列出复习日期的例子程序：

import java.util.*;

public class ShowDates {
   public static void main(String[] args) {
      ReviewDates rd = new ReviewDates();
      rd.listDates();

      GregorianCalendar gc = new GregorianCalendar(2001, Calendar.JANUARY, 15);
      ReviewDates jan15 = new ReviewDates(gc);
      jan15.listDates();
   }
}

总结
 这篇文章介绍了关于日期处理的3个重要的类：Date,DateFormat,GregorianCalendar.这些类让你创建日期，转换成字符串，和计算日期基本元素。处理Java中的日期问题，这篇文章只是冰山一角。可是，我在这里介绍的类和方法不仅仅是你学习高级技术的跳板，这些类和方法本身就可以处理很多通常的日期相关的任务
关于作者
 Robert Nielsen是SCJP。他拥有硕士学位，专攻计算机教育，并且在计算机领域执教多年。他也在各样的杂志上发表过很多计算机相关的文章。
关于译者
Cocia Lin(cocia@163.com)是程序员。他拥有学士学位，现在专攻Java相关技术，刚刚开始在计算机领域折腾。

许多大型企业的网站, 渐渐采用了 portal server 作为开发的基础. 至于什么是 portal 呢, 中文翻译为 "门户网站"。 有人可能想.. 天杀的.. 门户网站不是就像 yahoo, pchome, yam 等等。不过, 我们现在讨论的 portal server, 不是那么地简单, 基本上 yahoo, pchome, yam 那些只能称为搜索引擎的门户网站。

如果你从来沒有用过 portal server 或是似懂非懂.. 大家可以连结到 MyNetscape 或 MyYahoo 去 注册一个帐号。因为 MyNetscape 的样式比较好看, 所以我接下来就以 MyNetscape 为介绍的范例。

如果你第一次接触到 portal，你会惊讶的发现... 哇.. 为何一个网站里面充满了这么多小窗口. 我们称这些小窗口叫做 "portlet"，而且每个小窗口都存在着独立的信息与内容，可以放到最大化，缩小，还原，关闭等等。当你登陆之后，可以选择及调整自己 portlet 的配置，也可以设置自己喜爱的风格与样式，更可以设置每个 portlet 的资料配置。这种以客户为上帝的系统，就是我们将要介绍的 portal。

ch2 Portal 的组成

Portal 的组成可以分为三部份 (1) Portal Server (2) Portlet Container (3) Portlet

1) Portal Server 的定义是

一个 Portal（门户网站）就是指一个 Web-based 的系统，通常都会提供个人化设置、单一登陆、以及由各种不同来源或不同网站取得各式各样的信息，并且将这些信息放在网页之中组合而成的呈现平台，门户网站会有精巧的个人化设置去提供定制的网页，当不同等级的使用者来浏览该页面将获得不同的信息内容。

2) Portlet Container 的定义是

portlet container 是提供 portlets 执行的环境，包含了许多 portlets 并且管理他们的生命周期，他也会永远保存着 portlets 的喜好设置，一个 portlet container 接收到来自 portal 的请求后，接着将这个请求传递给存在 container 的 portlet 执行。portlet container 没有义务去组合 portlets 产生的信息內容，这个工作必须由 portal 来处理。portal 和 portlet container 可以放在一起视为同一个系统的组件，或者分开成为两个独立的组件。

3) Portlet 的定义是

一个 Portlet 是以 Java 技术为技术的 Web 组件，由 Portlet Container 所管理，专门处理客户的 request 以及产生各种动态的信息内容。Portlets 为可插式 ( pluggable ) 的客户界面组件，提供呈现层成为一个信息系统。这些由 portlet 产生的内容也被称为片段 (fragment)，而片段是具有一些规则的Markup( HTML、XHTML、WML )，而且可以和其他的片段组合而成一个复杂的文件。而 Portlet 中的内容正常来说是与其他 Portlet 的内容聚合而成为一个 Portal 网页。而 Portlet 的生命周期是被 Portlet Container 所管理控制的。客户端和 portlets 的互动是由 portal 通过典型的 request/response 方式实现，正常来说，客户会和 portlets 所产生的内容互动，举例来说，根据下一步的连接或者是确认送出的表单，结果 portal 将会接收到 portlet 的动作，将这个处理状况转向到目标 portlet。这些 portlet 内容的产生可能会因为不同的使用者而有不同的变化，完全是根据客户对于这个 portlet 的设置。

ch3 portlet 与 servlet 的关系

Portlet 和 Servlet 算是兄弟有那么一点点相似却又有那么一点点不同，因为 Servlet 和 Portlet 不尽然相同，所以研究小組決定将 portlets 定义成为一个新的组件，因此定义了 portlets 一个新的并且明确的界面与行为。为了尽可能与现有的 servlet 结合达到重复使用的目的，portlet 的规范利用了 servlet 的规范，许多观念都很相似的，结合 portlets、servlets 及 jsp 在同一个网站系统中，我们称为 portlet application 。在同一个 portlet application 中，他们将分享同一个 classloader，context 及 session。

1) Portlet 和 Servlet 的相似之处

@ portlets 也是 Java 技术的 web 组件
@ portlets 也是有特定的 container 在管理
@ portlets 可以动态产生各种内容
@ portlets 的生命周期由 container 所管理
@ portlets 和客户端的互动是通过 request/response 的机制

2) Portlet 和 Servlet 也有一些不同

@ portlets 只产生 markup 信息片段，不是完整的网页文件。而 Portal 会将所有的 Portlet markup 信息片 段放到一个完整的 Portal 网页。
@ portlets 不会和 URL 有直接的关系
@ 客户端必须通过 portal 系统才能和 portlets 互动
@ portlets 有一些定义好的 request 处理，action request 以及 render request。
@ portlets 默认定义 portlet modes 及窗口状态可以指出在网页中该 portlet 的哪个功能正在执行及现在的 状态。
@ portlets 可以在同一个 portal 网页之中存在多个。

3) Portlet 有一些附加的功能是 Servlet 所没有的

@ Portlets 能够存取及储存永久配置文件及定制资料。
@ portlets 可以存取使用者数据
@ portlets 具有 URL 的重写功能在文件中去动态建立连结，允许 portal server 不用去知道如何在网页的片 段之中建立连结及动作。
@ portlets 可以储存临时性的数据在 portlet session 之中，拥有两个不同的范围 ：
application-wide scope 及 portlet private scope 。

4) Portlet 不具有一些功能， 但是 Servlet 却有提供

@ servlet 具有设置輸出的文字编码( character set encoding)方式
@ servlet 可以设置 HTTP 输出的 header
@ servlet 才能夠接收客户对于 portal 发出的 URL 请求

ch4 RI - pluto 冥王星计划

JSR 是由 JCP ( www.jcp.org ) 这个 Java 组织所定义出来的规范。几乎每个 JSR 都会产出 TCK* 及 RI**

*TCK ( Technology Compatibility Kit ) 兼容性测试组件
*RI ( Reference Implementation ) 实现参考

2003/10/27 JSR#168 Portlet Spec 1.0 已经正式公布。以后, 大家就可以开始根据这个规范开发兼容性的产品。而这个标准规范书的 RI 就是采用 Apache Jakarta Pluto 冥王星计划。至于为何叫做冥王星,我猜是 Sun 想要把光芒射到冥王星都会发光吧 :P

目前 pluto 尚未有正式的版本释放, 将来有兴趣的人可以从 jakarta 网站下载。不过目前我由 CVS 取得版本已经可以正常运行了。安装的方法十分简单.. 只需要执行 %pluto%/bin/install 就可以安装了，安装过程会询问你 tomcat 的目录，假设你 tomcat 根目录是 c:\tomcat4.1.27 ，你输入 c:\tomcat4.1.27 就可以了。

接着 http://localhost:8080/pluto/portal 就可以看到很漂亮的 portal 界面，至于操作模式与方法非常简单，请多加操控就可以慢慢了解 portlet 的控制方法了。

在 portlet spec 中定义的控制有分为
1) 基本的 Portlet Modes
VIEW - 你没有做任何动作仅仅做内容显示
EDIT - 编辑相关的设置
HELP - 寻求帮助

2) 基本的 Window States
NORMAL - 还原 portlet 窗口
MAXIMIZED - 最大化 portlet 窗口
MINMIZED - 最小化 portlet 窗口

其实, 这些动作都已经由 portal 所实现，portlet container 将接收与回应相关的动作。真正在程序开发上并不会考虑到这些细节，除非你要做一個 portlet container。而开发上要考虑的是什么人能夠做什么事情。例如说尚未登陆的人应该只能夠 doView / doHelp，而不能夠 doEdit 这种权限管控机制的开发。

ch5 css 定义

每个通过认证的使用者，就可以使用相关的 portlet 外观 ( Look&Feel )设置，而这些设置就是通过 css 来 编辑。在没有 portlet spec 之前，各家厂商都自行规定或由 ISV 各自完成，造成了許多 portlet 无法共用同一份 CSS 来实现，移植上将会有许多问题发生。

因此 css 的定义对于具有定制功能的 portal 是相当重要的。

0) Anchor
这个并没有定义 :P

1) Fonts ( font )
portlet-font
portlet-font-dim

2) Message ( paragraph .. )
portlet-msg-status
portlet-msg-info
portlet-msg-error
portlet-msg-alert
portlet-msg-success

3) Sections ( table, div, span ... )
portlet-section-header
portlet-section-body
portlet-section-alternate
portlet-section-selected
portlet-section-subheader
portlet-section-footer
portlet-section-text

4) Forms ( form )
portlet-form-label
portlet-form-input-field
portlet-form-button
portlet-icon-label
portlet-dlg-icon-label
portlet-form-field-label
portlet-form-field

5) menus ( popup menu )
portlet-menu
portlet-menu-item
portlet-menu-item-selected
portlet-menu-item-hover
portlet-menu-item-hover-selected
portlet-menu-cascade-item
portlet-menu-cascade-item-selected
portlet-menu-description
portlet-menu-caption

基本上, 你要了解什么地方该用什么 css，这些 css 名称套用在你开发的 portlet 之中，你就可以移植到其他支持 jsr#168 的系统，不需要在花时间去更改成为他们的 Look&Feel。

ch6 信息片段 ( fragment markup ) 的限制