ebuddy    http://ebuddy.com/#BETA
支持MSN、Yahoo、AIM，提供Wap登陆。

Web QQ    http://webqq.qq.com/
QQ 的 Web IM，已经可以使用了。

mabber    http://www.mabber.com/
Beta中,支持AIM、ICQ、Yahoo! Messenger、Jabber、Gtalk和MSN，速度比较慢。

AIM    http://www.aim.com/get_aim/express/aim_expr.adp
AIM自己的Web IM。

MSN    http://webmessenger.msn.com/
Microsoft 自己的Web IM。

ICQ    http://www.icq.com/download/icq2go/
ICQ开发的的ICQ Web IM。

koolim    http://www.koolim.com/
支持AIM、ICQ、Yahoo! Messenger、Jabber、Gtalk、MSN。
imhaha    http://www.imhaha.com/
支持QQ哟，另外还支持MSN、Yahoo!Messenger，AIM。
 
radiusim    http://www.radiusim.com/
支持AIM、Yahoo messager!、MSN、Gtalk。

问题2：我的MP3能看多大的AMV
回答：MP3/MP4的屏幕大小尺寸如下：
1.0英寸 屏幕大小96×64
1.1英寸 屏幕大小96×64
1.2英寸 屏幕大小160×128
1.3英寸 屏幕大小160×128
1.5英寸 屏幕大小128×128
1.8英寸 屏幕大小128×160
目前市场上最常见的是1.5英寸和1.8英寸的MP3/MP4。
MP3/MP4只能播放比自己屏幕尺寸小的AMV视频，例如1.8寸的就可以播放96×64、128×96、160×120的视频。而1.5寸的则无法播放160×120的AMV视频。

问题3：为什么我的AMV不能满屏播放
回答：我们先来看下MP3/MP4的屏幕大小：
1.5寸屏幕是128×128也就是1:1
1.8寸屏幕是160×128也就是5:4
而我们知道，大部分的视频的标准比例是4:3，而宽屏电影是16:9。这就是为什么我们看宽屏电影会有上下两条黑色的遮幅。
这样问题就清楚了，所有下载的视频都是4:3的标准比例，于是放到1.5寸的机器里就是128×96；而放到1.8寸机器里就是160×120，看起来就不是满屏了。如果下载的是宽屏电影的话，则上下会被遮挡的更多。

问题4：为什么我看128×128满屏会感觉画面不全
回答：128×128的视频虽然看起来是满屏的，但其实是在170×128的视频上切割而成的，于是视频在宽度上就会别截掉很多。看起来是满屏的，其实是看不到全画面的。

问题5：为什么我播放一半会提示格式错误
回答：因为现在MP3/MP4采用的解码芯片各不相同，而压制出来的AMV并不能保证兼容所有的MP3/MP4机器。因此可能会出现播放一半提示错误的问题。

问题6：怎么制作AMV
回答：如何制作AMV请参阅：http://www.go2tv.net/read.php?tid-1892.html

问题7：为什么我制作RMVB时出错了
回答：视频的转换本来就是很复杂的一件事情。各种视频有着各种各样不同的视频音频编码（可参见http://www.go2tv.net/read.php?tid-215.html）。要转换RMVB就必须要有RMVB的解码程序，需要安装real的解码器。但是有时虽然两个文件是同一个视频格式例如RMVB但其实它们采用的视频编码可能是完全不同的，所以有的RMVB能够顺利的转成AMV，有的就不行！
对于不能转的RMVB，有一个方法是先把它转成3GP再转到AMV。

问题8：为什么我转换AMV时提示磁盘已满
回答：AMV转换精灵在使用过程中有一个很奇怪的BUG！在转换较大的文件时会提示磁盘已满！
这个需要安装AMV转换精灵的那个磁盘空间大于4G！

问题9：为什么我下载的AMV文件是RAR文档
回答：不知道什么原因，在有些朋友的机器上AMV文件会被关联到RAR文件上。双击后会调用WINRAR打开。解决方式是改变AMV文件的关联，关联到AMV播放器即可。或者每次都用AMV播放器来打开，而不是用双击！

问题10：为什么在电脑上不能看AMV文件
回答：电脑上要看AMV文件需要特殊的播放软件－AMV播放器！
可以在：http://www.go2tv.net/read.php?tid-1892.html 下载到转换器和播放器

问题11：哪里有AMV制作工具下载
回答：可以在：http://www.go2tv.net/read.php?tid-1892.html 下载到转换器和播放器以及有详细教程

问题12：能不能把128×96 AMV转换成160×120的AMV
回答：AMV转换工具不支持AMV格式作为源文件，也就是无法从AMV转换到AMV。

问题13：为什么我的视频文件转成AMV后大了很多啊
回答：视频文件的大小是由它的编码率来决定的，相同时间长度的视频有越高的kbps就会有越大的文件。而AMV转换工具默认的图像品质是middle，它的编码率比较高，如果选择high就会更高。同时还因为AMV压缩算法的不同，以及声音编码的不同，所以会造成AMV文件比源文件要大的结果。

问题14：我转换出来的AMV文件上下颠倒，怎么办啊？
回答：找到 AMVConverter的安装目录进入，打开 AmvTransform.ini 文件（可用window自带的记事本打开），找到BMPADJUST字段并修改。
BMPADJUST，对应的意义如下：
BMPADJUST=0 - 正常
BMPADJUST=1 - 画面垂直翻转
BMPADJUST=2 - 画面水平翻转
BMPADJUST=3 - 画面180 度旋转
BMPADJUST=4 - 画面顺时针 90 度旋转
BMPADJUST=5 - 画面逆时针 90 度旋转
修改后保存退出，重新启动AMVConverter即可。

问题15：哪里有1.8寸160×120的AMV制作工具下载
回答：160×120转换器下载：http://www.go2tv.net/read.php?tid-3792.html

问题16：如何在AMV里加入大一些的字幕？
回答：AMV转换工具是无法加载字幕的。想要在AMV中加载大字幕，只有通过两次转换的方式。可以给影片加载字幕的软件很多，例如可以先使用EO VIDEO，Easy RealMedia Producer，SmartMovie Converter等工具为源文件加上大的字幕！再用AMV转换工具把加了大字幕的源文件转换成AMV文件

2006年6月14日 上午 10:15:00
发表者：王忻，Google 工程师

最近三年作为 Google（谷歌）的软件工程师，我每周会帮人事部门审查简历，决定要不要给他们面试。Google 这几年的发展让很多许多优秀的工程师都前来申请。到目前为止，我已经看了上千份简历，有些简历留下的印象比别的好很多。尤其是最近亲戚朋友常常问我如何修改他们的简历，所以我积累了一些常见的错误避免的提议，在此跟大家交流一下。

1．谈到你做过的技术时，应该提到用的程序语言、你的个人贡献和产品细节。

有时我看到有人把过去的经验在简历上一笔带过，比如说：

• 在三人小组里，为电子邮件软件写了些 features。

这是远远不够的，看简历的人希望了解你做的工作的难度和对本公司有多少联系，所以你最好写的具体一些。譬如：

• 用 C++ 语言写了网络电子邮件的自动 backups。在三人小组里，专门负责设计和写储存服务器。从设计开始， 一年后把这个功能 feature 的用户推到了三千。

2．多讲事实, 少用形容词。

看简历的人读你的简历时，需要做判断，所以在简历里需要事实和数目。如果你写“迅速的提高了软件的操作效率”，看简历的人很难判断你成就的难度。但如果你写“在3个星期内，把软件的操作效率提高了40%” 就好多了。

有些谦虚的朋友们不愿意把话说满，所以你也可以用这个办法。你如果说自己“突出”或“在项目上常常被请去救火”，听起来难免会有点骄傲。但你也可以用不能否认的事实来说明你的观点，如“《纽约日报》评这个产品为‘突出’”，或“加入了三个原本已落后于计划的项目小组，但经过努力和组员一起把它们都按时完成了。”

3．你获得的奖、商业的荣誉或表扬、受用户欢迎的产品和你做过的有难度的业余项目都该包括在简历里。

我有位朋友在硅谷一个著名的硬件公司做了六年，她设计的 IP phone（网络电话）为公司赚了上亿的收入，被公司与商业报道多次评了奖。我有一次在旧金山的高速公路上驾车时，看到路边有她产品的广告牌；还有一次我去上海度假时，竟然发现上海公路边上也有！

不久，这位朋友决定换工作，请我看看她的简历。我惊讶的发现，她居然轻描淡写的写了一句-- "1998 – 2004：网络电话产品的硬件工程师组长" 和她的职责。

"产品赢的奖呢？它为公司赚的钱呢？" 我追问到。

"那些也该写吗？" 她说。

当然该写。

有人问，业余时间做的项目可不可以写？我觉得只要你的项目有代表性能说明对你的能力，都该包括。

4．分清主次，删掉相比之下不起眼的成绩，以免冲淡更加突出的成绩。

有朋友问，写简历是不是写的越多越好？譬如：

在甲公司做暑假实习生——
* 改善电子游戏的数值分类算法， 减少了内存要求 10%。
* 用 Java 写了 3000 行用户界面程序。
* 每周做两小时的人工测试。

你在申请软件工程师的职位时，我觉得前两点比较相关，第三点其实就不必写了。有时我看到有的简历里会提到，"按时完成了任务，产品符合原计划规格"。但读简历的人通常会认为这是理所当然的，而你把这些声明出来反而减弱简历的效果。

写一份简历不容易，但写好了也会带来成就感 （和好工作！）。 Google （谷歌）在中国广召各方面的人才，你不妨可以给我们投个简历！我们不但在信息检索方面招雇工程师，还有计算机图形、用户界面、硬件、Windows、质量保证员和系统管理员等方面。更多信息，请您访问这里。

谢谢阅读！大家感兴趣的话，下次我可以介绍“如何预备软件工程师的面试”。

以下以《Java与模式》中的示例为例：

抽象角色：
abstract public class Subject {
   abstract public void request();
} 

真实角色：实现了Subject的request()方法。
public class RealSubject extends Subject {
    public RealSubject() { }
   
    public void request() {
        System.out.println("From real subject.");
    }
}

代理角色：
public class ProxySubject extends Subject {
    private RealSubject realSubject; //以真实角色作为代理角色的属性

    public ProxySubject() { }

    public void request() { //该方法封装了真实对象的request方法
        preRequest();

        if( realSubject == null ) {

            realSubject = new RealSubject();
        }

        realSubject.request(); //此处执行真实对象的request方法

        postRequest();
    }

    private void preRequest() {
        //something you want to do before requesting
    }

    private void postRequest() {
        //something you want to do after requesting
    }
}

客户端调用：
Subject sub=new ProxySubject();
Sub.request();

由以上代码可以看出，客户实际需要调用的是RealSubject类的request()方法，现在用ProxySubject来代理 RealSubject类，同样达到目的，同时还封装了其他方法(preRequest(),postRequest())，可以处理一些其他问题。

另外，如果要按照上述的方法使用代理模式，那么真实角色必须是事先已经存在的，并将其作为代理对象的内部属性。但是实际使用时，一个真实角色必须对应一个 代理角色，如果大量使用会导致类的急剧膨胀；此外，如果事先并不知道真实角色，该如何使用代理呢？这个问题可以通过Java的动态代理类来解决。
 
2.动态代理类

Java动态代理类位于Java.lang.reflect包下，一般主要涉及到以下两个类：

(1). Interface InvocationHandler：该接口中仅定义了一个方法Object：invoke(Object obj,Method method, Object[] args)。在实际使用时，第一个参数obj一般是指代理类，method是被代理的方法，如上例中的request()，args为该方法的参数数组。 这个抽象方法在代理类中动态实现。

(2).Proxy：该类即为动态代理类，作用类似于上例中的ProxySubject，其中主要包含以下内容：

Protected Proxy(InvocationHandler h)：构造函数，估计用于给内部的h赋值。

Static Class getProxyClass (ClassLoader loader, Class[] interfaces)：获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。

Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)：返回代理类的一个实例，返回后的代理类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法)。

所谓Dynamic Proxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该class就宣称它实现了这些 interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然啦，这个Dynamic Proxy其实就是一个Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。

在使用动态代理类时，我们必须实现InvocationHandler接口，以第一节中的示例为例：

抽象角色(之前是抽象类，此处应改为接口)：

public interface Subject {
   abstract public void request();
}

具体角色RealSubject：
public class RealSubject implements Subject{

  public RealSubject(){}

  public void request(){
    System.out.println("From real subject.");
  }

}

代理处理器：
import java.lang.reflect.Method;

import java.lang.reflect.InvocationHandler;

public class DynamicSubject implements InvocationHandler {
  private Object sub;
  public DynamicSubject() {}

  public DynamicSubject(Object obj) {
    sub = obj;
  }

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   System.out.println("before calling " + method);
   method.invoke(sub,args);

   System.out.println("after calling " + method);
   return null;
 }

}

该代理类的内部属性为Object类，实际使用时通过该类的构造函数DynamicSubject(Object obj)对其赋值；此外，在该类还实现了invoke方法，该方法中的

method.invoke(sub,args);

其实就是调用被代理对象的将要被执行的方法，方法参数sub是实际的被代理对象，args为执行被代理对象相应操作所需的参数。通过动态代理类，我们可以在调用之前或之后执行一些相关操作。

客户端：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class Client {

static public void main(String[] args) throws Throwable {

   RealSubject rs = new RealSubject(); //在这里指定被代理类
   InvocationHandler ds = new DynamicSubject(rs);
   Class cls = rs.getClass();

   //以下是一次性生成代理
   Subject subject = (Subject) Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),ds );
   subject.request();

}

程序运行结果：
before calling public abstract void Subject.request()
From real subject.
after calling public abstract void Subject.request()

通过这种方式，被代理的对象(RealSubject)可以在运行时动态改变，需要控制的接口(Subject接口)可以在运行时改变，控制的方式(DynamicSubject类)也可以动态改变，从而实现了非常灵活的动态代理关系。
 

转载地址：
http://www.java3z.com/cwbwebhome/article/article2/2300.jsp?id=846
http://www.csdn.net/develop/Article/26/26750.shtm 

1）跟新买家建立联系

Dear Mr. Jones:

We understand from your information posted on Alibaba.com that you are in the market for textiles. We would like to take this opportunity to introduce our company and products, with the hope that we may work with Bright Ideas Imports in the future.

We are a joint venture specializing in the manufacture and export of textiles. We have enclosed our catalog, which introduces our company in detail and covers the main products we supply at present. You may also visit our online company introduction at Http://xxxxxxxxxx.icxo.com which includes our latest product line.

Should any of these items be of interest to you, please let us know. We will be happy to give you a quotation upon receipt of your detailed requirements.

We look forward to receiving your enquires soon.

Sincerely,

John Roberts

Company:XXXXXXX
ADD:XXXXXXX
TEL:XXXXXXXX
FAX:XXXXXXXXX
EMAIL:XXXXXXXXX HTTP://WWW.XXXXXXXXXX

2）对新买家要求建立业务联系的回复

Dear Mr. Jones:

We have received your letter of 9th April showing your interest in our complete product information.

Our product lines mainly include high quality textile products. To give you a general idea of the various kinds of textiles now available for export, we have enclosed a catalogue and a price list. You may also visit our online company introduction at Http://xxxxxxxxxx.icxo.com which includes our latest product line.

We look forward to your specific enquiries and hope to have the opportunity to work together with you in the future.

Sincerely,

John Roberts

Company:XXXXXXX
ADD:XXXXXXX
TEL:XXXXXXXX
FAX:XXXXXXXXX
EMAIL:XXXXXXXXX HTTP://WWW.XXXXXXXXXX

3）向老客户介绍公司的最新产品信息

Dear Mr. Jones:

We have refreshed our online catalog at http://xxxxxxxxxxx.com, and now it covers the latest new products, which are now available from stock.

We believe that you will find some attractive additions to our product line. Once you have had time to study the supplement, please let us know if you would like to take the matter further. We would be very happy to send samples to you for close inspection.

We will keep you informed on our progress and look forward to hearing from you.

Sincerely,

John Roberts

Company:XXXXXXX
ADD:XXXXXXX
TEL:XXXXXXXX
FAX:XXXXXXXXX
EMAIL:XXXXXXXXX HTTP://WWW.XXXXXXXXXX

　　在Google.com里面进行搜索的时候，经常会遇到突然出现“该页无法显示”的提示，并且之后的十多分钟都无法正常连接Google，这里给出一些方法，可以解决大部分Google无法访问或进不去的问题。

　　1、如果是搜索过程中出现“该页无法显示”的提示，接着就无法访问Google，那么对于ADSL用户，可以尝试断开网络连接，然后重新拨号上网，这样你的IP地址就发生了变化，这时候就可以正常访问Google了。（其原理是防火墙只是针对IP封用户，而不是针对独立电脑）

　　2、如果一开始就无法访问Google，那么请把下面这一行：

　　216.239.63.104　www.google.com 或 64.233.171.99　www.google.com 或 216.239.53.99　www.google.com

　　添加到：C:\WINDOWS\system32\drivers\etc\hosts文件里，就着访问Google看看是否正常。（其原理是提供较为少用的Google镜像访问）

　　3、使用附录中的Google的镜像IP地址来访问Google，那么多的IP，应该不至于全都封了吧。

　　4、使用Google.cn来访问Google，不过请注意，Google.cn服务器也在美国，因此搜索词语的时候也会出现“该页无法显示”的可能。

　　5、如果碰到DNS劫持的封锁方法，那么需要选择正确的DNS服务器，将主DNS设置成国外根服务器的DNS，然后辅助DNS设置成国外的DNS。具体做法：在拨号网络或网卡属性里设置，主DNS设成 202.12.27.33，辅助DNS：202.216 .228.18（日本DNS）大家还可以自己找一些快的国外DNS。 （其原理是DNS劫持只能够控制国内的DNS服务器，而对于国外的DNS服务器则无能为力，因此只要不使用国内的DNS即可）

　　6、对于GMail，使用http访问访问的话最好不要选择“带有聊天功能的标准视图”，否则容易被封。

　　7、尽量使用https://mail.google.com 来访问GMail，这将极大提高访问的稳定性，并且在GMail里使用GTalk也不会被封。（其原理是对于加密的https，防火墙无能为力）

　　8、使用加密的代理服务器软件来访问Google，当然目前的一些加密的代理服务器都不是很稳定，速度也不是很理想。

　　当然，上面的方法有时可能会实效，我觉得最简单的方法应该是来自Google的，就是提供一个支持https版本的Google搜索，这可以一劳永逸地解决目前几乎所有的问题，而且我知道增加这个版本对于Google来说应该是举手之劳的事情，并且GMail都已经提供了，那么为什么对于我们用的更多的Web搜索不提供呢？https是安全访问网站的一个重要的方法，目前还没有看到能截获https的加密数据的防火墙，那么与其提供Google.cn，其实还不如提供一个https的Google更实用。

　　当然，在大多数国家，使用https访问Google都显得很多余，但请Google理解https对于中国用户的重要性，并且实现https访问也是轻而易举的事情，又何乐而不为呢。

　　附录：Google的IP地址一览表：http://216.239.37.103 http://216.239.57.99 http://64.233.187.107
http://216.239.37.105 http://216.239.59.103 http://64.233.187.89
http://216.239.37.106 http://216.239.59.104 http://64.233.187.99
http://216.239.37.107 http://216.239.59.105 http://66.102.11.104
http://216.239.39.100 http://216.239.59.106 http://66.102.11.105
http://216.239.39.102 http://216.239.59.107 http://66.102.11.106
http://216.239.39.103 http://216.239.59.147 http://66.102.11.107
http://216.239.39.106 http://216.239.59.98 http://66.102.11.99
http://216.239.39.107 http://216.239.59.99 http://66.102.7.104
http://216.239.51.100 http://216.239.63.104 http://66.102.7.105
http://216.239.51.103 http://216.239.63.91 http://66.102.7.106
http://216.239.53.102 http://216.239.63.93 http://66.102.7.107
http://216.239.53.103 http://216.239.63.99 http://66.102.7.147
http://216.239.53.104 http://64.233.161.104 http://66.102.7.18
http://216.239.53.106 http://64.233.161.105 http://66.102.7.19
http://216.239.53.107 http://64.233.161.106 http://66.102.7.89
http://216.239.53.99 http://64.233.161.107 http://66.102.7.91
http://216.239.55.102 http://64.233.161.89 http://66.102.7.95
http://216.239.57.103 http://64.233.163.104 http://66.102.7.99
http://216.239.57.104 http://64.233.163.106 http://66.102.9.104
http://216.239.57.105 http://64.233.163.99 http://66.102.9.105
http://216.239.57.106 http://64.233.183.91 http://66.102.9.106
http://216.239.57.107 http://64.233.183.93 http://66.102.9.107
http://216.239.57.147 http://64.233.183.99 http://66.102.9.147
http://216.239.57.98 http://64.233.187.104 http://66.102.9.99

转载自月光博客 [ http://www.williamlong.info ]

另外在看一下数据库的CPU占用率，如果占用率在经常在80%－100%，那一定要是SQL或存储过程及trigger中写的不好。

不需要从应用层找SQL，方向性错误，太累，也看不出效果。
而应当使用pl/SQL, toad等工具，分析出最bad的SQL语句，一看到这些语句后，再修改应用层的查询就是了。又快又方便。

-- 逻辑读多的SQL
select * from (select buffer_gets, sql_text
from v$sqlarea
where buffer_gets > 500000
order by buffer_gets desc) where rownum<=30;

-- 执行次数多的SQL
select sql_text,executions from
(select sql_text,executions from v$sqlarea order by executions desc)
where rownum<81;

-- 读硬盘多的SQL
select sql_text,disk_reads from
(select sql_text,disk_reads from v$sqlarea order by disk_reads desc)
where rownum<21;

-- 排序多的SQL
select sql_text,sorts from
(select sql_text,sorts from v$sqlarea order by sorts desc)
where rownum<21;

--分析的次数太多，执行的次数太少，要用绑变量的方法来写sql
set pagesize 600;
set linesize 120;
select substr(sql_text,1,80) "sql", count(*), sum(executions) "totexecs"
from v$sqlarea
where executions < 5
group by substr(sql_text,1,80)
having count(*) > 30
order by 2;

转载地址 http://forum.javaeye.com/viewtopic.php?t=19464

摘要：虽然session机制在web应用程序中被采用已经很长时间了，但是仍然有很多人不清楚session机制的本质，以至不能正确的应用这一技术。本文将详细讨论session的工作机制并且对在Java web application中应用session机制时常见的问题作出解答。

目录：
一、术语session
二、HTTP协议与状态保持
三、理解cookie机制
四、理解session机制
五、理解javax.servlet.http.HttpSession
六、HttpSession常见问题
七、跨应用程序的session共享
八、总结
参考文档

一、术语session
在我的经验里，session这个词被滥用的程度大概仅次于transaction，更加有趣的是transaction与session在某些语境下的含义是相同的。

session，中文经常翻译为会话，其本来的含义是指有始有终的一系列动作/消息，比如打电话时从拿起电话拨号到挂断电话这中间的一系列过程可以称之为一个session。有时候我们可以看到这样的话“在一个浏览器会话期间，...”，这里的会话一词用的就是其本义，是指从一个浏览器窗口打开到关闭这个期间①。最混乱的是“用户（客户端）在一次会话期间”这样一句话，它可能指用户的一系列动作（一般情况下是同某个具体目的相关的一系列动作，比如从登录到选购商品到结账登出这样一个网上购物的过程，有时候也被称为一个transaction），然而有时候也可能仅仅是指一次连接，也有可能是指含义①，其中的差别只能靠上下文来推断②。

然而当session一词与网络协议相关联时，它又往往隐含了“面向连接”和/或“保持状态”这样两个含义，“面向连接”指的是在通信双方在通信之前要先建立一个通信的渠道，比如打电话，直到对方接了电话通信才能开始，与此相对的是写信，在你把信发出去的时候你并不能确认对方的地址是否正确，通信渠道不一定能建立，但对发信人来说，通信已经开始了。“保持状态”则是指通信的一方能够把一系列的消息关联起来，使得消息之间可以互相依赖，比如一个服务员能够认出再次光临的老顾客并且记得上次这个顾客还欠店里一块钱。这一类的例子有“一个TCP session”或者“一个POP3 session”③。

而到了web服务器蓬勃发展的时代，session在web开发语境下的语义又有了新的扩展，它的含义是指一类用来在客户端与服务器之间保持状态的解决方案④。有时候session也用来指这种解决方案的存储结构，如“把xxx保存在session里”⑤。由于各种用于web开发的语言在一定程度上都提供了对这种解决方案的支持，所以在某种特定语言的语境下，session也被用来指代该语言的解决方案，比如经常把Java里提供的javax.servlet.http.HttpSession简称为session⑥。

鉴于这种混乱已不可改变，本文中session一词的运用也会根据上下文有不同的含义，请大家注意分辨。
在本文中，使用中文“浏览器会话期间”来表达含义①，使用“session机制”来表达含义④，使用“session”表达含义⑤，使用具体的“HttpSession”来表达含义⑥

二、HTTP协议与状态保持
HTTP协议本身是无状态的，这与HTTP协议本来的目的是相符的，客户端只需要简单的向服务器请求下载某些文件，无论是客户端还是服务器都没有必要纪录彼此过去的行为，每一次请求之间都是独立的，好比一个顾客和一个自动售货机或者一个普通的（非会员制）大卖场之间的关系一样。

然而聪明（或者贪心？）的人们很快发现如果能够提供一些按需生成的动态信息会使web变得更加有用，就像给有线电视加上点播功能一样。这种需求一方面迫使HTML逐步添加了表单、脚本、DOM等客户端行为，另一方面在服务器端则出现了CGI规范以响应客户端的动态请求，作为传输载体的HTTP协议也添加了文件上载、cookie这些特性。其中cookie的作用就是为了解决HTTP协议无状态的缺陷所作出的努力。至于后来出现的session机制则是又一种在客户端与服务器之间保持状态的解决方案。

让我们用几个例子来描述一下cookie和session机制之间的区别与联系。笔者曾经常去的一家咖啡店有喝5杯咖啡免费赠一杯咖啡的优惠，然而一次性消费5杯咖啡的机会微乎其微，这时就需要某种方式来纪录某位顾客的消费数量。想象一下其实也无外乎下面的几种方案：
1、该店的店员很厉害，能记住每位顾客的消费数量，只要顾客一走进咖啡店，店员就知道该怎么对待了。这种做法就是协议本身支持状态。
2、发给顾客一张卡片，上面记录着消费的数量，一般还有个有效期限。每次消费时，如果顾客出示这张卡片，则此次消费就会与以前或以后的消费相联系起来。这种做法就是在客户端保持状态。
3、发给顾客一张会员卡，除了卡号之外什么信息也不纪录，每次消费时，如果顾客出示该卡片，则店员在店里的纪录本上找到这个卡号对应的纪录添加一些消费信息。这种做法就是在服务器端保持状态。

由于HTTP协议是无状态的，而出于种种考虑也不希望使之成为有状态的，因此，后面两种方案就成为现实的选择。具体来说cookie机制采用的是在客户端保持状态的方案，而session机制采用的是在服务器端保持状态的方案。同时我们也看到，由于采用服务器端保持状态的方案在客户端也需要保存一个标识，所以session机制可能需要借助于cookie机制来达到保存标识的目的，但实际上它还有其他选择。

三、理解cookie机制
cookie机制的基本原理就如上面的例子一样简单，但是还有几个问题需要解决：“会员卡”如何分发；“会员卡”的内容；以及客户如何使用“会员卡”。

正统的cookie分发是通过扩展HTTP协议来实现的，服务器通过在HTTP的响应头中加上一行特殊的指示以提示浏览器按照指示生成相应的cookie。然而纯粹的客户端脚本如Javascript或者VBscript也可以生成cookie。

而cookie的使用是由浏览器按照一定的原则在后台自动发送给服务器的。浏览器检查所有存储的cookie，如果某个cookie所声明的作用范围大于等于将要请求的资源所在的位置，则把该cookie附在请求资源的HTTP请求头上发送给服务器。意思是麦当劳的会员卡只能在麦当劳的店里出示，如果某家分店还发行了自己的会员卡，那么进这家店的时候除了要出示麦当劳的会员卡，还要出示这家店的会员卡。

cookie的内容主要包括：名字，值，过期时间，路径和域。
其中域可以指定某一个域比如.google.com，相当于总店招牌，比如宝洁公司，也可以指定一个域下的具体某台机器比如www.google.com或者froogle.google.com，可以用飘柔来做比。
路径就是跟在域名后面的URL路径，比如/或者/foo等等，可以用某飘柔专柜做比。
路径与域合在一起就构成了cookie的作用范围。
如果不设置过期时间，则表示这个cookie的生命期为浏览器会话期间，只要关闭浏览器窗口，cookie就消失了。这种生命期为浏览器会话期的cookie被称为会话cookie。会话cookie一般不存储在硬盘上而是保存在内存里，当然这种行为并不是规范规定的。如果设置了过期时间，浏览器就会把cookie保存到硬盘上，关闭后再次打开浏览器，这些cookie仍然有效直到超过设定的过期时间。

存储在硬盘上的cookie可以在不同的浏览器进程间共享，比如两个IE窗口。而对于保存在内存里的cookie，不同的浏览器有不同的处理方式。对于IE，在一个打开的窗口上按Ctrl-N（或者从文件菜单）打开的窗口可以与原窗口共享，而使用其他方式新开的IE进程则不能共享已经打开的窗口的内存cookie；对于Mozilla Firefox0.8，所有的进程和标签页都可以共享同样的cookie。一般来说是用javascript的window.open打开的窗口会与原窗口共享内存cookie。浏览器对于会话cookie的这种只认cookie不认人的处理方式经常给采用session机制的web应用程序开发者造成很大的困扰。

下面就是一个goolge设置cookie的响应头的例子
HTTP/1.1 302 Found
Location: http://www.google.com/intl/zh-CN/
Set-Cookie: PREF=ID=0565f77e132de138:NW=1:TM=1098082649:LM=1098082649:S=KaeaCFPo49RiA_d8; expires=Sun, 17-Jan-2038 19:14:07 GMT; path=/; domain=.google.com
Content-Type: text/html

这是使用HTTPLook这个HTTP Sniffer软件来俘获的HTTP通讯纪录的一部分

浏览器在再次访问goolge的资源时自动向外发送cookie

使用Firefox可以很容易的观察现有的cookie的值
使用HTTPLook配合Firefox可以很容易的理解cookie的工作原理。

IE也可以设置在接受cookie前询问

这是一个询问接受cookie的对话框。

四、理解session机制
session机制是一种服务器端的机制，服务器使用一种类似于散列表的结构（也可能就是使用散列表）来保存信息。

当程序需要为某个客户端的请求创建一个session的时候，服务器首先检查这个客户端的请求里是否已包含了一个session标识 - 称为session id，如果已包含一个session id则说明以前已经为此客户端创建过session，服务器就按照session id把这个session检索出来使用（如果检索不到，可能会新建一个），如果客户端请求不包含session id，则为此客户端创建一个session并且生成一个与此session相关联的session id，session id的值应该是一个既不会重复，又不容易被找到规律以仿造的字符串，这个session id将被在本次响应中返回给客户端保存。

保存这个session id的方式可以采用cookie，这样在交互过程中浏览器可以自动的按照规则把这个标识发挥给服务器。一般这个cookie的名字都是类似于SEEESIONID，而。比如weblogic对于web应用程序生成的cookie，JSESSIONID=ByOK3vjFD75aPnrF7C2HmdnV6QZcEbzWoWiBYEnLerjQ99zWpBng!-145788764，它的名字就是JSESSIONID。

由于cookie可以被人为的禁止，必须有其他机制以便在cookie被禁止时仍然能够把session id传递回服务器。经常被使用的一种技术叫做URL重写，就是把session id直接附加在URL路径的后面，附加方式也有两种，一种是作为URL路径的附加信息，表现形式为http://...../xxx;jsessionid=ByOK3vjFD75aPnrF7C2HmdnV6QZcEbzWoWiBYEnLerjQ99zWpBng!-145788764
另一种是作为查询字符串附加在URL后面，表现形式为http://...../xxx?jsessionid=ByOK3vjFD75aPnrF7C2HmdnV6QZcEbzWoWiBYEnLerjQ99zWpBng!-145788764
这两种方式对于用户来说是没有区别的，只是服务器在解析的时候处理的方式不同，采用第一种方式也有利于把session id的信息和正常程序参数区分开来。
为了在整个交互过程中始终保持状态，就必须在每个客户端可能请求的路径后面都包含这个session id。

另一种技术叫做表单隐藏字段。就是服务器会自动修改表单，添加一个隐藏字段，以便在表单提交时能够把session id传递回服务器。比如下面的表单
<form name="testform" action="/xxx">
<input type="text">
</form>
在被传递给客户端之前将被改写成
<form name="testform" action="/xxx">
<input type="hidden" name="jsessionid" value="ByOK3vjFD75aPnrF7C2HmdnV6QZcEbzWoWiBYEnLerjQ99zWpBng!-145788764">
<input type="text">
</form>
这种技术现在已较少应用，笔者接触过的很古老的iPlanet6(SunONE应用服务器的前身)就使用了这种技术。
实际上这种技术可以简单的用对action应用URL重写来代替。

在谈论session机制的时候，常常听到这样一种误解“只要关闭浏览器，session就消失了”。其实可以想象一下会员卡的例子，除非顾客主动对店家提出销卡，否则店家绝对不会轻易删除顾客的资料。对session来说也是一样的，除非程序通知服务器删除一个session，否则服务器会一直保留，程序一般都是在用户做log off的时候发个指令去删除session。然而浏览器从来不会主动在关闭之前通知服务器它将要关闭，因此服务器根本不会有机会知道浏览器已经关闭，之所以会有这种错觉，是大部分session机制都使用会话cookie来保存session id，而关闭浏览器后这个session id就消失了，再次连接服务器时也就无法找到原来的session。如果服务器设置的cookie被保存到硬盘上，或者使用某种手段改写浏览器发出的HTTP请求头，把原来的session id发送给服务器，则再次打开浏览器仍然能够找到原来的session。

恰恰是由于关闭浏览器不会导致session被删除，迫使服务器为seesion设置了一个失效时间，当距离客户端上一次使用session的时间超过这个失效时间时，服务器就可以认为客户端已经停止了活动，才会把session删除以节省存储空间。

五、理解javax.servlet.http.HttpSession
HttpSession是Java平台对session机制的实现规范，因为它仅仅是个接口，具体到每个web应用服务器的提供商，除了对规范支持之外，仍然会有一些规范里没有规定的细微差异。这里我们以BEA的Weblogic Server8.1作为例子来演示。

首先，Weblogic Server提供了一系列的参数来控制它的HttpSession的实现，包括使用cookie的开关选项，使用URL重写的开关选项，session持久化的设置，session失效时间的设置，以及针对cookie的各种设置，比如设置cookie的名字、路径、域，cookie的生存时间等。

一般情况下，session都是存储在内存里，当服务器进程被停止或者重启的时候，内存里的session也会被清空，如果设置了session的持久化特性，服务器就会把session保存到硬盘上，当服务器进程重新启动或这些信息将能够被再次使用，Weblogic Server支持的持久性方式包括文件、数据库、客户端cookie保存和复制。

复制严格说来不算持久化保存，因为session实际上还是保存在内存里，不过同样的信息被复制到各个cluster内的服务器进程中，这样即使某个服务器进程停止工作也仍然可以从其他进程中取得session。

cookie生存时间的设置则会影响浏览器生成的cookie是否是一个会话cookie。默认是使用会话cookie。有兴趣的可以用它来试验我们在第四节里提到的那个误解。

cookie的路径对于web应用程序来说是一个非常重要的选项，Weblogic Server对这个选项的默认处理方式使得它与其他服务器有明显的区别。后面我们会专题讨论。

关于session的设置参考[5] http://e-docs.bea.com/wls/docs70/webapp/weblogic_xml.html#1036869

六、HttpSession常见问题
（在本小节中session的含义为⑤和⑥的混合）

1、session在何时被创建
一个常见的误解是以为session在有客户端访问时就被创建，然而事实是直到某server端程序调用HttpServletRequest.getSession(true)这样的语句时才被创建，注意如果JSP没有显示的使用 <%@page session="false"%> 关闭session，则JSP文件在编译成Servlet时将会自动加上这样一条语句HttpSession session = HttpServletRequest.getSession(true);这也是JSP中隐含的session对象的来历。

由于session会消耗内存资源，因此，如果不打算使用session，应该在所有的JSP中关闭它。

2、session何时被删除
综合前面的讨论，session在下列情况下被删除a.程序调用HttpSession.invalidate();或b.距离上一次收到客户端发送的session id时间间隔超过了session的超时设置;或c.服务器进程被停止（非持久session）

3、如何做到在浏览器关闭时删除session
严格的讲，做不到这一点。可以做一点努力的办法是在所有的客户端页面里使用javascript代码window.oncolose来监视浏览器的关闭动作，然后向服务器发送一个请求来删除session。但是对于浏览器崩溃或者强行杀死进程这些非常规手段仍然无能为力。

4、有个HttpSessionListener是怎么回事
你可以创建这样的listener去监控session的创建和销毁事件，使得在发生这样的事件时你可以做一些相应的工作。注意是session的创建和销毁动作触发listener，而不是相反。类似的与HttpSession有关的listener还有HttpSessionBindingListener，HttpSessionActivationListener和HttpSessionAttributeListener。

5、存放在session中的对象必须是可序列化的吗
不是必需的。要求对象可序列化只是为了session能够在集群中被复制或者能够持久保存或者在必要时server能够暂时把session交换出内存。在Weblogic Server的session中放置一个不可序列化的对象在控制台上会收到一个警告。我所用过的某个iPlanet版本如果session中有不可序列化的对象，在session销毁时会有一个Exception，很奇怪。

6、如何才能正确的应付客户端禁止cookie的可能性
对所有的URL使用URL重写，包括超链接，form的action，和重定向的URL，具体做法参见[6]
http://e-docs.bea.com/wls/docs70/webapp/sessions.html#100770

7、开两个浏览器窗口访问应用程序会使用同一个session还是不同的session
参见第三小节对cookie的讨论，对session来说是只认id不认人，因此不同的浏览器，不同的窗口打开方式以及不同的cookie存储方式都会对这个问题的答案有影响。

8、如何防止用户打开两个浏览器窗口操作导致的session混乱
这个问题与防止表单多次提交是类似的，可以通过设置客户端的令牌来解决。就是在服务器每次生成一个不同的id返回给客户端，同时保存在session里，客户端提交表单时必须把这个id也返回服务器，程序首先比较返回的id与保存在session里的值是否一致，如果不一致则说明本次操作已经被提交过了。可以参看《J2EE核心模式》关于表示层模式的部分。需要注意的是对于使用javascript window.open打开的窗口，一般不设置这个id，或者使用单独的id，以防主窗口无法操作，建议不要再window.open打开的窗口里做修改操作，这样就可以不用设置。

9、为什么在Weblogic Server中改变session的值后要重新调用一次session.setValue
做这个动作主要是为了在集群环境中提示Weblogic Server session中的值发生了改变，需要向其他服务器进程复制新的session值。

10、为什么session不见了
排除session正常失效的因素之外，服务器本身的可能性应该是微乎其微的，虽然笔者在iPlanet6SP1加若干补丁的Solaris版本上倒也遇到过；浏览器插件的可能性次之，笔者也遇到过3721插件造成的问题；理论上防火墙或者代理服务器在cookie处理上也有可能会出现问题。
出现这一问题的大部分原因都是程序的错误，最常见的就是在一个应用程序中去访问另外一个应用程序。我们在下一节讨论这个问题。

七、跨应用程序的session共享

常常有这样的情况，一个大项目被分割成若干小项目开发，为了能够互不干扰，要求每个小项目作为一个单独的web应用程序开发，可是到了最后突然发现某几个小项目之间需要共享一些信息，或者想使用session来实现SSO(single sign on)，在session中保存login的用户信息，最自然的要求是应用程序间能够访问彼此的session。

然而按照Servlet规范，session的作用范围应该仅仅限于当前应用程序下，不同的应用程序之间是不能够互相访问对方的session的。各个应用服务器从实际效果上都遵守了这一规范，但是实现的细节却可能各有不同，因此解决跨应用程序session共享的方法也各不相同。

首先来看一下Tomcat是如何实现web应用程序之间session的隔离的，从Tomcat设置的cookie路径来看，它对不同的应用程序设置的cookie路径是不同的，这样不同的应用程序所用的session id是不同的，因此即使在同一个浏览器窗口里访问不同的应用程序，发送给服务器的session id也可以是不同的。

根据这个特性，我们可以推测Tomcat中session的内存结构大致如下。

笔者以前用过的iPlanet也采用的是同样的方式，估计SunONE与iPlanet之间不会有太大的差别。对于这种方式的服务器，解决的思路很简单，实际实行起来也不难。要么让所有的应用程序共享一个session id，要么让应用程序能够获得其他应用程序的session id。

iPlanet中有一种很简单的方法来实现共享一个session id，那就是把各个应用程序的cookie路径都设为/（实际上应该是/NASApp，对于应用程序来讲它的作用相当于根）。
<session-info>
<path>/NASApp</path>
</session-info>

需要注意的是，操作共享的session应该遵循一些编程约定，比如在session attribute名字的前面加上应用程序的前缀，使得setAttribute("name", "neo")变成setAttribute("app1.name", "neo")，以防止命名空间冲突，导致互相覆盖。

在Tomcat中则没有这么方便的选择。在Tomcat版本3上，我们还可以有一些手段来共享session。对于版本4以上的Tomcat，目前笔者尚未发现简单的办法。只能借助于第三方的力量，比如使用文件、数据库、JMS或者客户端cookie，URL参数或者隐藏字段等手段。

我们再看一下Weblogic Server是如何处理session的。

从截屏画面上可以看到Weblogic Server对所有的应用程序设置的cookie的路径都是/，这是不是意味着在Weblogic Server中默认的就可以共享session了呢？然而一个小实验即可证明即使不同的应用程序使用的是同一个session，各个应用程序仍然只能访问自己所设置的那些属性。这说明Weblogic Server中的session的内存结构可能如下

对于这样一种结构，在session机制本身上来解决session共享的问题应该是不可能的了。除了借助于第三方的力量，比如使用文件、数据库、JMS或者客户端cookie，URL参数或者隐藏字段等手段，还有一种较为方便的做法，就是把一个应用程序的session放到ServletContext中，这样另外一个应用程序就可以从ServletContext中取得前一个应用程序的引用。示例代码如下，

应用程序A
context.setAttribute("appA", session);

应用程序B
contextA = context.getContext("/appA");
HttpSession sessionA = (HttpSession)contextA.getAttribute("appA");

值得注意的是这种用法不可移植，因为根据ServletContext的JavaDoc，应用服务器可以处于安全的原因对于context.getContext("/appA");返回空值，以上做法在Weblogic Server 8.1中通过。

那么Weblogic Server为什么要把所有的应用程序的cookie路径都设为/呢？原来是为了SSO，凡是共享这个session的应用程序都可以共享认证的信息。一个简单的实验就可以证明这一点，修改首先登录的那个应用程序的描述符weblogic.xml，把cookie路径修改为/appA访问另外一个应用程序会重新要求登录，即使是反过来，先访问cookie路径为/的应用程序，再访问修改过路径的这个，虽然不再提示登录，但是登录的用户信息也会丢失。注意做这个实验时认证方式应该使用FORM，因为浏览器和web服务器对basic认证方式有其他的处理方式，第二次请求的认证不是通过session来实现的。具体请参看[7] secion 14.8 Authorization，你可以修改所附的示例程序来做这些试验。

八、总结
session机制本身并不复杂，然而其实现和配置上的灵活性却使得具体情况复杂多变。这也要求我们不能把仅仅某一次的经验或者某一个浏览器，服务器的经验当作普遍适用的经验，而是始终需要具体情况具体分析。

关于作者：
郎云鹏（dev2dev ID: hippiewolf），软件工程师，从事J2EE开发
电子邮件：langyunpeng@yahoo.com.cn
地址：大连软件园路31号科技大厦A座大连博涵咨询服务有限公司

参考文档：
[1] Preliminary Specification http://wp.netscape.com/newsref/std/cookie_spec.html
[2] RFC2109 http://www.rfc-editor.org/rfc/rfc2109.txt
[3] RFC2965 http://www.rfc-editor.org/rfc/rfc2965.txt
[4] The Unofficial Cookie FAQ http://www.cookiecentral.com/faq/
[5] http://e-docs.bea.com/wls/docs70/webapp/weblogic_xml.html#1036869
[6] http://e-docs.bea.com/wls/docs70/webapp/sessions.html#100770
[7] RFC2616 http://www.rfc-editor.org/rfc/rfc2616.txt

代码下载：http://dev2dev.bea.com.cn/images/paihang_article/041020/sampleApp.zip

转载地址：http://www.supcode.com/Article/html/4/43/2005/06/29/216335472190.shtml

我们看到，号码牌（Session ID）必须包含在HTTP Request里面。关于HTTP Request的具体格式，请参见HTTP协议（http://www.w3.org/Protocols/）。这里只做一个简单的介绍。
在Java Web Server（即Servlet/JSP Server）中，Session ID用jsessionid表示（请参见Servlet规范）。
HTTP Request一般由3部分组成：
（1）Request Line
这一行由HTTP Method（如GET或POST）、URL、和HTTP版本号组成。
例如，GET http://www.w3.org/pub/WWW/TheProject.html HTTP/1.1
GET http://www.google.com/search?q=Tomcat HTTP/1.1
POST http://www.google.com/search HTTP/1.1
GET http://www.somsite.com/menu.do;jsessionid=1001 HTTP/1.1

（2）Request Headers
这部分定义了一些重要的头部信息，如，浏览器的种类，语言，类型。Request Headers中还可以包括Cookie的定义。例如：
User-Agent: Mozilla/4.0 (compatible; MSIE 5.5; Windows NT 5.0)
Accept-Language: en-us
Cookie: jsessionid=1001

（3）Message Body
如果HTTP Method是GET，那么Message Body为空。
如果HTTP Method是POST，说明这个HTTP Request是submit一个HTML Form的结果，
那么Message Body为HTML Form里面定义的Input属性。例如，
user=guest
password=guest
jsessionid=1001
主意，如果把HTML Form元素的Method属性改为GET。那么，Message Body为空，所有的Input属性都会加在URL的后面。你在浏览器的URL地址栏中会看到这些属性，类似于
http://www.somesite/login.do?user=guest&password=guest&jsessionid=1001

从理论上来说，这3个部分（Request URL，Cookie Header, Message Body）都可以用来存放Session ID。由于Message Body方法必须需要一个包含Session ID的HTML Form，所以这种方法不通用。
一般用来实现Session的方法有两种：
（1）URL重写。
Web Server在返回Response的时候，检查页面中所有的URL，包括所有的连接，和HTML Form的Action属性，在这些URL后面加上“;jsessionid=XXX”。
下一次，用户访问这个页面中的URL。jsessionid就会传回到Web Server。
（2）Cookie。
如果客户端支持Cookie，Web Server在返回Response的时候，在Response的Header部分，加入一个“set-cookie: jsessionid=XXXX”header属性，把jsessionid放在Cookie里传到客户端。
客户端会把Cookie存放在本地文件里，下一次访问Web Server的时候，再把Cookie的信息放到HTTP Request的“Cookie”header属性里面，这样jsessionid就随着HTTP Request返回给Web Server。

我们来看Tomcat5的源代码如何支持jsessionid。
org.apache.coyote.tomcat5.CoyoteResponse类的toEncoded()方法支持URL重写。
String toEncoded(String url, String sessionId) {
…
StringBuffer sb = new StringBuffer(path);
if( sb.length() > 0 ) { // jsessionid can't be first.
sb.append(";jsessionid=");
sb.append(sessionId);
}
sb.append(anchor);
sb.append(query);
return (sb.toString());
}

我们来看org.apache.coyote.tomcat5.CoyoteRequest的两个方法configureSessionCookie()
doGetSession()用Cookie支持jsessionid.

/**
* Configures the given JSESSIONID cookie.
*
* @param cookie The JSESSIONID cookie to be configured
*/
protected void configureSessionCookie(Cookie cookie) {
…
}

HttpSession doGetSession(boolean create){
…
// Creating a new session cookie based on that session
if ((session != null) && (getContext() != null)
&& getContext().getCookies()) {
Cookie cookie = new Cookie(Globals.SESSION_COOKIE_NAME,
session.getId());
configureSessionCookie(cookie);
((HttpServletResponse) response).addCookie(cookie);
}
…
}

Session的典型应用是存放用户的Login信息，如用户名，密码，权限角色等信息，应用程序（如Email服务、网上银行等系统）根据这些信息进行身份验证和权限验证

王森在他的《Java深度历险》（强力推荐这本书，内容少而精）的第一章就解释了JDK，JRE，JVM之间的关系。解释了我们执行java.exe时
发生的事情。其中提到，java.exe依照一套逻辑来寻找可以用的JRE，首先查找自己�诘哪柯枷掠忻挥蠮RE（据王森讲这样说不确切，我没有
JDK全部的源代码，在此无从考证）；其次查找自己的父目录下有没有JRE；最后才是查询Windows的注册表。

通常我们在安装好了JRE的机器上的任何一个目录下都可以执行java.exe。因为它在安装时被复制到了windows的system32目录下，而后者
无论如何都会在path环境变量中。这个java.exe最终必然会访问注册表来确定真正的JRE的所在地。若我们要求每一个应用程序都自带JRE，
必然不能走这条路。但，逻辑的第二条讲，java.exe会在它的父目录下查找JRE，解决方案就在这一条中。

假设我们的应用程序打好了包，叫做MyApp.jar，放在MyApp的目录下。我们在MyApp目录下，可以执行java –jar MyApp.jar来运行我们
的程序。我们安装的是JRE 1.5，在C:\Program Files\Java\jre1.5.0下。现在，我们只需要简单的将jre1.5.0目录搬到MyApp目录下，顺
便改个容易写的名字比如叫jre。现在，我们的应用程序就象这样：

MyApp

       MyApp.jar

       Jre

              Jre1.5.0目录下的全部内容

Java.exe就在jre目录下的bin目录中。根据第二条逻辑，java.exe会在它的父目录中查找jre，实验证实，它会查找lib目录，而lib就在jre目
录下。因此，这样java.exe就会确定jre的所在然后正常执行java程序，不会去管我们是否安装了JRE，注册表中是否有注册项这些杂事了。

试一下，在命令行下进入MyApp的目录下，假设它在C盘，将path指向MyApp下的JRE：

set path=c:\MyApp\jre\bin

然后运行：

java –verbose –jar MyApp.jar

加上verbose参数以确定我们确实用了这一套被搬出了家的JRE。

程序可以运行，并且在命令行输出的前几行，可以看到：

[Opened C:\MyApp\jre\lib\rt.jar]

[Opened C:\MyApp\jre\lib\jsse.jar]

[Opened C:\MyApp\jre\lib\jce.jar]

[Opened C:\MyApp\jre\lib\charsets.jar]

因此程序读取的确实是它的私有的JRE。

至此，我们似乎完成了任务。但是现在我们的私有JRE仍不完美，缺点是太大。JRE 1.5有接近70MB，作为我们的私有的JRE，好多内容都是
可以抛弃的。Jre目录下的license都可以不要，bin下的执行文件只需要保留java.exe或者javaw.exe，lib下只要保留
rt，jsse，jce，charsets几个库就可以了。除了i386和zi两个子目录外，其余的子目录都可以不要。Zi下只需要保留自己地区的子目录和其下
的一些文件就可以。Lib下除了库之外的属性文件等等都要保留。这样清理一番，JRE仍然有接近50MB。还可以继续清理几个库文件里面不需
要的内容，这需要仔细的整理，会很费功夫。最好能写出一个自动工具帮助我们整理它们。从Sun公司上下到的JMF里面附带的用Java写的媒
体播放器就自带了JRE，只有几个MB。

清理过后需要运行几遍我们的应用程序，以确保我们的JRE不缺少东西。

如果我们希望能有一个程序直接启动我们的应用程序，那就还要费些功夫。最简单的方法是弄出一个快捷方式来，但是快捷方式的路径不能是相
对的，不方便我们安装。我想到的方案就是用Win32程序包装一下。在VS.NET下写一个Win32小程序：

int PASCAL WinMain( HINSTANCE hInstance,

    HINSTANCE hPrevInstance,

    LPSTR lpszCmdLine,

    int nCmdShow )

{

    STARTUPINFO si;

    PROCESS_INFORMATION pi;

    ZeroMemory( &si, sizeof(si) );

    si.cb = sizeof(si);

    ZeroMemory( &pi, sizeof(pi) );

    // Start the child process.

    if( !CreateProcess( "jre\\bin\\javaw.exe",//执行的程序名

                        "jre\\bin\\javaw.exe -jar MyApp.jar", // 带参数的执行程序

            NULL,             // Process handle not inheritable.

            NULL,             // Thread handle not inheritable.

            FALSE,            // Set handle inheritance to FALSE.

            0,                // No creation flags.

            NULL,             // Use parent’s environment block.

            NULL,             // Use parent’s starting directory.

            &si,              // Pointer to STARTUPINFO structure.

            &pi )             // Pointer to PROCESS_INFORMATION structure.

    )

    {

            ErrorExit( "CreateProcess failed." );

    }

     // Wait until child process exits.

    WaitForSingleObject( pi.hProcess, INFINITE );

     // Close process and thread handles.

    CloseHandle( pi.hProcess );

    CloseHandle( pi.hThread );

}

基本上是按照MSDN文档中的例子照搬的。将它编译成一个EXE文件，我们的任务才全部完成。双击这个EXE文件，我们的程序启动了，看起来
和传统的Win32程序没有两样，JRE完全被隐藏在底层。

转载地址 http://www.matrix.org.cn/resource/article/44/44085_java.html

http://forum.javaeye.com/viewtopic.php?t=1603

但是并没有得出明确的结论。先让我们看看事务的定义：

引用:

Transactions are described in terms of ACID properties, which are as follows:
n Atomic: all changes to the database made in a transaction are rolled back if any
change fails.
n Consistent: the effects of a transaction take the database from one consistent
state to another consistent state.
n Isolated: the intermediate steps in a transaction are not visible to other users of
the database.
n Durable: when a transaction is completed (committed or rolled back), its effects
persist in the database.
 

即ACID的定义，从上面看来，似乎除了isolated之外，和只读查询都没有关系。那么是否只读查询不需要事务呢？

再看看Oracle对于只读事务的定义：

引用:
Read-Only Transactions
By default, Oracle guarantees statement-level read consistency. The set of data returned by a single query is consistent with respect to a single point in time. However, in some situations, you might also require transaction-level read consistency. This is the ability to run multiple queries within a single transaction, all of which are read-consistent with respect to the same point in time, so that queries in this transaction do not see the effects of intervening committed transactions.

If you want to run a number of queries against multiple tables and if you are not doing any updating, you prefer a read-only transaction. After indicating that your transaction is read-only, you can run as many queries as you like against any table, knowing that the results of each query are consistent with respect to the same point in time.

Oracle默认情况下保证了SQL语句级别的读一致性，即在该条SQL语句执行期间，它只会看到执行前点的数据状态，而不会看到执行期间数据被其他SQL改变的状态。

而Oracle的只读查询(read-only transaction)则保证了事务级别的读一致性，即在该事务范围内执行的多条SQL都只会看到执行前点的数据状态，而不会看到事务期间的任何被其他SQL改变的状态。

因此我们可以得出结论：

如果你一次执行单条查询语句，则没有必要启用事务支持，数据库默认支持SQL执行期间的读一致性；
如果你一次执行多条查询语句，例如统计查询，报表查询，在这种场景下，多条查询SQL必须保证整体的读一致性，否则，在前条SQL查询之后，后条SQL查询之前，数据被其他用户改变，则该次整体的统计查询将会出现读数据不一致的状态，此时，应该启用事务支持。

只读事务与读写事务区别

对于只读查询，可以指定事务类型为readonly，即只读事务。由于只读事务不存在数据的修改，因此数据库将会为只读事务提供一些优化手段，例如Oracle对于只读事务，不启动回滚段，不记录回滚log。

在JDBC中，指定只读事务的办法为：
connection.setReadOnly(true);

在Hibernate中，指定只读事务的办法为：
session.setFlushMode(FlushMode.NEVER);
此时，Hibernate也会为只读事务提供Session方面的一些优化手段

在Spring的Hibernate封装中，指定只读事务的办法为：
bean配置文件中，prop属性增加“readOnly”

我在MySQL4.1试验了一下，过程和结果如下：

数据库：MySQL4.1
表类型：InnoDB
Spring：1.1.2
Hibernate：2.1.7

使用Spring的声明式事务管理

试验过程如下：

不设置查询方法的事务类型(即不需要事务)：访问查询页面，后台执行Spring的Bean方法，让Hibernate发送select语句，然后手工在MySQL里面修改该记录某字段值，再访问查询页面，发现被修改过的字段值并没有变化，Hibernate输出的log显示，数据库还是把老的字段值返回，而没有返回新的字段值。

设置查询方法的事务类型(只读事务)：访问查询页面，后台执行Spring的Bean方法，让Hibernate发送select语句，然后手工在MySQL里面修改该记录某字段值，再访问查询页面，发现被修改过的字段值已经变化，Hibernate输出的log显示，数据库返回新的字段值。

这个试验说明，至少在MySQL4.1的InnoDB情况下，不使用只读事务的查询将无法读取到数据更新值，必须使用只读事务来保证读记录的数据一致性。这个结果非常令我诧异，和我预期完全两样。

我将在Oracle平台上试试看会有什么样的结果。

BTW: 如果MySQL的表类型改为MyISAM，那么即使不设置事务，也不会出现读数据不一致的现象。

oracle有两种方法保证在事务级读数据一致性(Transaction-Level Read Consistency)

一是用SET TRANSACTION ISOLATION LEVEL SERIALIZABLE ,
当执行这条命令后读数据时会产生一些重复copy, 你也可以做数据修改, 但在大量数据修改的情况下容易造成deadlock或异常, 用commit或rollback将把ISOLATION LEVEL设回为缺省模式read committed,

二是用SET TRANSCATION READ ONLY
当执行这条命令时数据库会生成一个快照的latch, 这个latch会耗费一些resource, 如果你想进行数据修改会导致异常. 用commit或rollback会把latch释放掉, 也将把ISOLATION LEVEL设回为缺省模式read committed,

选择自 calvinxiu 的 Blog  http://dev.csdn.net/user/calvinxiu

天寒地冻，呆在家里又读完了《Mastering Oracle SQL》2nd，发现Oracle的功能还是很强悍，光函数就有两百个，HSQL是很难比拟的。接下来的硬骨头，看来要么冒险用Hibernate3.0 的SQL Mapping功能，要么就自己跑JDBC组装VO了。

在ORACLE7、8数据库中只有数据库名(db_name)和数据库实例名(instance_name)。在ORACLE8i、9i中出现了新的参数，即数据库域名(db_domain)、服务名(service_name)、以及操作系统环境变量(ORACLE_SID)。这些都存在于同一个数据库中的标识，用于区分不同数据库的参数。

一、什么是数据库名(db_name)? 数据库名是用于区分数据的内部标识，是以二进制方式存储于数据库控制文件中的参数，在数据安装或创建之后将不得修改。数据库安装完成后，该参数被写入数据库参数文件pfile中，格式如下：

db_name="orcl"
db_domain=dbcenter.toys.com
instance_name=orcl
service_names=orcl.dbcenter.toys.com
control_file=...............

在每一个运行的ORACLE8i数据库中都有一个数据库名(db_name),如果一个服务器程序中创建了两个数据库，则有两个数据库名。其控制参数据分属在不同的pfile中控制着相关的数据库。

二、什么是数据库实例名(instance_name) 数据库实例名则用于和操作系统之间的联系，用于对外部连接时使用。在操作系统中要取得与数据库之间的交互，必须使用数据库实例名。例如，要和某一个数据库server连接，就必须知道其数据库实例名，只知道数据库名是没有用的，与数据库名不同，在数据安装或创建数据库之后，实例名可以被修改。数据库安装完成后，该实例名被写入数据库参数文件pfile中，格式如下：
db_name="orcl" #(不允许修改)
db_domain=dbcenter.toys.com
instance_name=orcl #(可以修改,可以与db_name相同也可不同)
service_names=orcl.dbcenter.toys.com
control_file=...............
数据库名与实例名之间的关系。 数据库名与实例名之间的关系一般是一一对应关系，有一个数据库名就有一个实例名，如果在一个服务器中创建两个数据库，则有两个数据库名，两个数据库实例名，用两个标识确定一个数据库，用户和实例相连接。 但在8i、9i的并行服务器结构中，数据库与实例之间不存在一一对应关系，而是一对多关系，(一个数据库对应多个实例，同一时间内用户只一个实例相联系，当某一实例出现故障，其它实例自动服务，以保证数据库安全运行。)

三、操作系统环境变量(ORACLE_SID) 在实际中，对于数据库实例名的描述有时使用实例名(instance_name)参数，有时使用ORACLE_SID参数。这两个都是数据库实例名，它们有什么区别呢？(经常弄混)

(ORACLE_SID) OS<----------------> ORACLE 数据库 <--------(Instance_name(实例名))

上图表示实例名instance_name、ORACLE_SID与数据库及操作系统之间的关系，虽然这里列出的两个参数都是数据库实例名，但instance_name参数是ORACLE数据库的参数，此参数可以在参数文件中查询到，而ORACLE_SID参数则是操作系统环境变量。 操作系统环境变量ORACLE_SID用于和操作系统交互。也就是说，在操作系统中要想得到实例名，就必须使用ORACLE_SID。此参数与ORACLE_BASE、ORACLE_HOME等用法相同。在数据库安装之后，ORACLE_SID被用于定义数据库参数文件的名称。如： $ORACLE_BASE/admin/DB_NAME/pfile/init$ORACLE_SID.ora。 定义方法:  export ORACLE_SID=orcl

如果在同一服务器中创建了多个数据库，则必然同时存在多个数据库实例,这时可以重复上述定义过程，以选择不同实例。

还可以用 [oracle@Datacent]$ . oraenv 来切换不同的ORACLE_SID来通过操作系统来启动不同的实例(instance)

1.下载：

把jakarta-tomcat-5.5.x.zip

和jakarta-tomcat-5.5.x-compat.zip

和jakarta-tomcat-5.5.x-admin.zip
(Tomcat 默认是没有内置admin模块了

Tomcat's administration web application is no longer installed by default. Download and install the "admin" package to use it. )

都解压到同一个目录下面。比如：D:\jakarta-tomcat-5.5.x\

(如果使用jdk1.4，才需要compat.zip用jdk1.5就可以免了这个。)

2.修改jakarta-tomcat-5.5.x\conf\tomcat-users.xml.
添加管理员账号lizongbo，密码为lizongbopass.
新xml如下：
<?xml version='1.0' encoding='utf-8'?>
<tomcat-users>
  <role rolename="tomcat"/>
  <role rolename="role1"/>
  <role rolename="manager"/>
  <role rolename="admin"/>
  <user username="tomcat" password="tomcat" roles="tomcat"/>
  <user username="role1" password="tomcat" roles="role1"/>
  <user username="both" password="tomcat" roles="tomcat,role1"/>
  <user username="lizongbo" password="lizongbopass" roles="admin,manager"/>
</tomcat-users>

3.修改jakarta-tomcat-5.5.x\conf\server.xml来解决编码问题。

(给Connector 添加URIEncoding参数
参考 http://blog.csdn.net/darkxie/archive/2004/10/25/TOMCATAPP.aspx)

(可以设置成GB18030)
    <Connector port="8080"
               maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
               enableLookups="false" redirectPort="8443" acceptCount="200"
               connectionTimeout="20000" disableUploadTimeout="true" URIEncoding="GBK"
               compression="on" compressionMinSize="2048"
      noCompressionUserAgents="gozilla, traviata"
      compressableMimeType="text/html,text/xml"/>

    <Connector port="8009"
               enableLookups="false" redirectPort="8443" protocol="AJP/1.3" URIEncoding="GBK"/>

4.启用支持gzip压缩.
(http://www.linuxaid.com.cn/forum/showdoc.jsp?l=1&i=81169)
添加下列属性
 compression="on"
      compressionMinSize="2048"
      noCompressionUserAgents="gozilla, traviata"
      compressableMimeType="text/html,text/xml"

5.设置虚拟主机。

在jakarta-tomcat-5.5.x\下建立文件夹vhost\www.mydomain.com。

然后修改jakarta-tomcat-5.5.x\conf\server.xml

<Engine defaultHost="localhost" name="Catalina">
      <Host appBase="vhost/www.mydomain.com" name="www.mydomain.com">
      </Host>
      <Host appBase="webapps" name="localhost">
      </Host>
      <Realm className="org.apache.catalina.realm.UserDatabaseRealm"/>
    </Engine>

6.添加数据库驱动,更新mail.jar和actiovation.jar

复制mysql-connector-java-3.0.16-ga-bin.jar,pg74.215.jdbc3.jar到 jakarta-tomcat-5.5.x\common\lib\

还有javamail 1.3.2的mail.jar，jaf-1_0_2的 activation.jar

msSQl 2000 JDBC sp3，msbase.jar,msutil,jar,mssqlserver.jar

7.配置SSL

参考 http://jakarta.apache.org/tomcat/tomcat-5.5-doc/ssl-howto.html

D:\j2sdk1.4.2_06\bin>%JAVA_HOME%\bin\keytool -genkey -alias tomcat -keyalg RSA
输入keystore密码：  lizongbossl
您的名字与姓氏是什么？
  [tomcat5.5.x]：  tomcat5.5.x
您的组织单位名称是什么？
  [jakarta]：  jakarta
您的组织名称是什么？
  [apache]：  apache
您所在的城市或区域名称是什么？
  [hzcity]：  hzcity
您所在的州或省份名称是什么？
  [gdp]：  gdp
该单位的两字母国家代码是什么
  [CN]：  CN
CN=tomcat5.5.x, OU=jakarta, O=apache, L=hzcity, ST=gdp, C=CN 正确吗？
  [否]：  y

输入<tomcat>的主密码
        （如果和 keystore 密码相同，按回车）：

(必须密码一致，因此直接回车)

然后再把userhome(例如：C:\Documents and Settings\lizongbo\)下的.keystore复制到

tomcat的conf\目录下。

 (例如：D:\jakarta-tomcat-5.5.x\conf\.keystore )

配置jakarta-tomcat-5.5.x\conf\server.xml

加上

    <Connector port="8443"
               maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
               enableLookups="false" disableUploadTimeout="true"
               acceptCount="100" scheme="https" secure="true"
               clientAuth="false" sslProtocol="TLS"
           keystoreFile="conf/.keystore"
           keystorePass="lizongbossl"> <!--与先前设置的密码一致-->
    </Connector>

8.禁止文件目录列表，

修改jakarta-tomcat-5.5.x\conf\web.xml，把listing设置为false

    <servlet>
        <servlet-name>default</servlet-name>
        <servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
        <init-param>
            <param-name>debug</param-name>
            <param-value>0</param-value>
        </init-param>
        <init-param>
            <param-name>listings</param-name>
            <param-value>true</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

 9.指定了自己的javaEncoding

(参考 http://gceclub.sun.com.cn/staticcontent/html/sunone/app7/app7-dg-webapp/ch6/ch6-4.html )

    <servlet>
        <servlet-name>jsp</servlet-name>
        <servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
        <init-param>
            <param-name>fork</param-name>
            <param-value>false</param-value>
        </init-param>
                <init-param>
            <param-name>javaEncoding</param-name>
            <param-value>GB18030</param-value>
        </init-param>
        <init-param>
            <param-name>xpoweredBy</param-name>
            <param-value>true</param-value>
        </init-param>
        <load-on-startup>3</load-on-startup>
    </servlet>

 10.添加rar,iso等的mime-type映射

避免在浏览器里直接打开。

<mime-mapping>
<extension>mht</extension>
<mime-type>text/x-mht</mime-type>
</mime-mapping>

<mime-mapping>
        <extension>rar</extension>
        <mime-type>application/octet-stream</mime-type>
    </mime-mapping>
    <mime-mapping>
        <extension>iso</extension>
        <mime-type>application/octet-stream</mime-type>
    </mime-mapping>
    <mime-mapping>
        <extension>ape</extension>
        <mime-type>application/octet-stream</mime-type>
    </mime-mapping>
    <mime-mapping>
        <extension>rmvb</extension>
        <mime-type>application/octet-stream</mime-type>
    </mime-mapping>

    <mime-mapping>
        <extension>ico</extension>
        <mime-type>image/x-icon</mime-type>
    </mime-mapping>

10.1对html静态页面设置编码
    <!--  修改下面两行以支持静态超文本的自动编码 -->
    <mime-mapping>
    <extension>htm</extension>
    <mime-type>text/html;charset=gb2312</mime-type>
    </mime-mapping>
    <mime-mapping>
    <extension>html</extension>
    <mime-type>text/html;charset=gb2312</mime-type>
    </mime-mapping>
  </web-app>

11.添加welcome-file-list，并调整顺序。

 <welcome-file-list>   
        <welcome-file>index.jsp</welcome-file>
        <welcome-file>index.html</welcome-file>
        <welcome-file>index.htm</welcome-file>
        <welcome-file>default.html</welcome-file>
        <welcome-file>default.htm</welcome-file>
        <welcome-file>default.jsp</welcome-file>
    </welcome-file-list>

1.版本管理工具和文本比较/合并工具
   用的是CVS: 绿毛小海龟加 WinMerge.  
   这年头，还有谁敢不用版本管理工具就跟人合作开发么？ 有的。
   一个好的Programmer，除了要有好的udpate/commit习惯外，会不会善用文本差异比较/合并工具是另一层次的观察标准。
   另外，因为重构时有用，版本管理工具要能和IDE结合。

2.项目计划，任务分配，需求变更管理，Bug管理工具
    偶然的，我发现自己把这些都交给了JIRA完成。

    项目计划，任务分配，进度跟踪，需求变更管理，Bug管理几乎就是PM的全部工作了。
    以前总有很多软件分开来管理这些问题，同一问题经常要Copy Paste好几个软件。
    但如果你的团队的项目计划是XP plan风格 而不是MS Project
    那恭喜了，一个JIRA就可以完成所有任务。

3.支持重构，Flying Error提示，TDD和Debug 的IDE

 Java: IDEA 5.0能满足下面的全部要求。 
 C++: VC7.1+VA，就差好多了。
 Ruby: Eclipse的RDT插件，就弱得一塌糊涂。
 Groovy:IDEA的插件Groovyj
 Php: Zend Stuido

 a.重构：即使团队用的最多的只是Rename，Move，Extract Method等有限几个最基本的功能，但J2EE结构里牵一发动全身的事情太多了，重构会帮你把事情擦干净，现在已形成依赖。

 b.Flying Error提示：
    Java IDE的标准配置了，有错马上提示，不要等编译时。可惜其他语言的IDE里这还不是标配。

  c.Debug J2EE应用：
     Web开发者一般用System.out或者log4j来显示调试信息，但对于曾经桌面编程的程序员来说，直接进入调试模式，单步跟踪程序执行路径，想看哪个变量就看哪个变量，才是天经地义的事情，只是之前的IDE不能支持而已。
    
  d.TDD：TDD不等于Unit Test。TDD是让你不用依赖表现层，不用手工输入数据，清除数据，不用重起Tomcat的开发。
    我们团队暂时还追求不起测试覆盖率，So，UntTest只是一种开发的手段，而不是测试的手段。

4.团队IM工具和共享文件夹
    前代是言必称Email的，现在配合Google Group也很好用，但我们更喜欢QQ 群的即时性。
    同时QQ 2005版的"来消息时只显示消息条数"的免打扰功能很重要。
    对于坐在一起的团队，在文件服务器上建个共享文件夹就够了。

5.知识库Wiki
   Java里JspWiki是最简单易装入门级wiki，但php世界里显然有更好的选择如Dokuwiki。
   我一直希望wiki语法有所见所得的编辑器。


其他工具包括纸，笔，足够大的白板，随时可用的会议室。

还缺了什么？
一、代码自动生成工具中也没有最趁手的。
二、因为没有足够的UnitTest用例，配好的持续集成工具没有实际运作。

http://www.blogjava.net/calvin/archive/2005/10/13/15422.html

        Beanutils用了魔术般的反射技术，实现了很多夸张有用的功能，都是C/C++时代不敢想的。无论谁的项目，始终一天都会用得上它。我算是后知后觉了，第一回看到它的时候居然错过。

1.属性的动态getter、setter
        在这框架满天飞的年代，不能事事都保证执行getter,setter函数了，有时候属性是要根据名字动态取得的，就像这样：　　
BeanUtils.getProperty(myBean,"code");
        而Common BeanUtils的更强功能在于可以直接访问内嵌对象的属性，只要使用点号分隔。
BeanUtils.getProperty(orderBean, "address.city");
相比之下其他类库的BeanUtils通常都很简单，不能访问内嵌的对象，所以有时要用Commons BeanUtils来替换它们。

BeanUtils还支持List和Map类型的属性，如下面的语法即可取得Order的顾客列表中第一个顾客的名字
BeanUtils.getProperty(orderBean, "customers[1].name");
其中BeanUtils会使用ConvertUtils类把字符串转为Bean属性的真正类型，方便从HttpServletRequest等对象中提取bean，或者把bean输出到页面。
而PropertyUtils就会原色的保留Bean原来的类型。

2.BeanCompartor 动态排序
        还是通过反射，动态设定Bean按照哪个属性来排序，而不再需要在实现bean的Compare接口进行复杂的条件判断。
        List peoples = ...; // Person对象的列表
        Collections.sort(peoples, new BeanComparator("age"));
如果要支持多个属性的复合排序，如"Order By lastName,firstName"

ArrayList sortFields = new ArrayList();
sortFields.add(new BeanComparator("lastName"));
sortFields.add(new BeanComparator("firstName"));
ComparatorChain multiSort = new ComparatorChain(sortFields);
Collections.sort(rows,multiSort);

其中ComparatorChain属于jakata commons-collections包。
如果age属性不是普通类型，构造函数需要再传入一个comparator对象为age变量排序。
另外, BeanCompartor本身的ComparebleComparator, 遇到属性为null就会抛出异常, 也不能设定升序还是降序。这个时候又要借助commons-collections包的ComparatorUtils.

   Comparator mycmp = ComparableComparator.getInstance();
   mycmp = ComparatorUtils.nullLowComparator(mycmp);  //允许null
   mycmp = ComparatorUtils.reversedComparator(mycmp); //逆序
   Comparator cmp = new BeanComparator(sortColumn, mycmp);

    MyBean bean = ...;
    HashMap map = new HashMap();
    Enumeration names = request.getParameterNames();
    while (names.hasMoreElements())
    {
      String name = (String) names.nextElement();
      map.put(name, request.getParameterValues(name));
    }
    BeanUtils.populate(bean, map);

    其中BeanUtils的populate方法或者getProperty,setProperty方法其实都会调用convert进行转换。
    但Converter只支持一些基本的类型，甚至连java.util.Date类型也不支持。而且它比较笨的一个地方是当遇到不认识的类型时，居然会抛出异常来。 对于Date类型，我参考它的sqldate类型实现了一个Converter，而且添加了一个设置日期格式的函数。
要把这个Converter注册，需要如下语句：

   ConvertUtilsBean convertUtils = new ConvertUtilsBean();
   DateConverter dateConverter = new DateConverter();
   convertUtils.register(dateConverter,Date.class);
 


   //因为要注册converter,所以不能再使用BeanUtils的静态方法了，必须创建BeanUtilsBean实例
   BeanUtilsBean beanUtils = new BeanUtilsBean(convertUtils,new PropertyUtilsBean());
   beanUtils.setProperty(bean, name, value);

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=277748