未来世界

兰迪语录：真正实现你的童年梦想

2008-11-18T06:24:00.001-08:00

兰迪语录：真正实现你的童年梦想

Brick walls are there for a reason: they let us prove how badly we want things.

人生路上有阻挡你梦想的砖墙，那是有原因的。这些砖墙让我们来证明我们究竟有多么想要得到我们所需要的。

Experience is what you get when you didn't get what you wanted.

当你得不到你想的到的东西时，你会得到经验。

Never lose the child-like wonder.

永远不要失去孩童一样的好奇心。

If we do something which is pioneering, we will get arrows in the
back. But at the end of the day, whether we succeed or not, the journey
will be worthwhile.

当我们做一些前人没做过的事情时，有人会放冷箭。然而，最后的结果是，无论我们是否成功，过程都是值得的。

Be good at something; it makes you valuable.

在某些方面要能突出你的专才，这会使你有价值。

If you live your life the right way, the karma will take care of itself, and the dreams will come to you.

如果你用正确方式地去度过你的一生，命运会让合适的梦想会来到你身边。

Stay positive no matter what, but not in denial.

无论发生什么事情，一定要往好的方面想，但是不要拒绝接受事实。

Make things fun.

凡事尽量弄得有趣些。

Dream a big dream.

有大的梦想。

Learn from all the people in your life.

向你生活中所有的人学习。

Be dare to do things differently.

大胆去用不同的方式来做事情。

Find the right place to nurture your dreams.

找一个适合你培养梦想的地方。

If you screwed up, and no one cares to say anything, that means you have been dropped. Criticism is your best friend.

如果你做错了，没人说你什么，那是因为别人已放弃了你。批评才是你最好的朋友。

Life is a gift. Find the good things from others. If you can wait long enough, the good side of other people will show.

生命是一个礼物。看别人好的一面。如果你给别人时间的话，他们好的一面会展现出来。

Don't go the short-cut, always tell the truth.

不要投机取巧，要永远说真话。

Don't complain, just work harder.

遇到困难，不要抱怨，要更加努力地去作。

深入浅析：面向对象编程四大原则

2008-11-18T06:23:00.003-08:00

深入浅析：面向对象编程四大原则

在面向对象设计中，如何通过很小的设计改变就可以应对设计需求的变化，这是令设计者极为关注的问题。为此不少OO先驱提出了很多有关面向对象的设计原则用于指导OO的设计和开发。下面是几条与类设计相关的设计原则。

　　1. 开闭原则(the Open Closed Principle OCP)

　　一个模块在扩展性方面应该是开放的而在更改性方面应该是封闭的。因此在进行面向对象设计时要尽量考虑接口封装机制、抽象机制和多态技术。该原则同样适合于非面向对象设计的方法，是软件工程设
计方法的重要原则之一。我们以收音机的例子为例，讲述面向对象的开闭原则。我们收听节目时需要打开收音机电源，对准电台频率和进行音量调节。但是对于不同
的收音机，实现这三个步骤的细节往往有所不同。比如自动收缩电台的收音机和按钮式收缩在操作细节上并不相同。因此，我们不太可能针对每种不同类型的收音机
通过一个收音机类来实现(通过重载)这些不同的操作方式。但是我们可以定义一个收音机接口，提供开机、关机、增加频率、降低频率、增加音量、降低音量六个
抽象方法。不同的收音机继承并实现这六个抽象方法。这样新增收音机类型不会影响其它原有的收音机类型，收音机类型扩展极为方便。此外，已存在的收音机类型
在修改其操作方法时也不会影响到其它类型的收音机。

　　2. 替换原则 (the Liskov Substitution Principle LSP)

　　子类应当可以替换父类并出现在父类能够出现的任何地方。这个原则是Liskov于1987年提出的设计原则。它同样可以从Bertrand Meyer 的DBC (Design by Contract) 的概念推出。

　　我们以学生为例，夜校生为学生的子类，因此在任何学生可以出现的地方，夜校生均可出现。这个例子有些牵强，一个能够反映这个原则的例子时圆和椭圆，圆是椭圆的一个特殊子类。因此任何出现椭圆的地方，圆均可以出现。但反过来就可能行不通。

　　运用替换原则时，我们尽量把类B设计为抽象类或者接口，让C类继承类B(接口B)并实现操作A和操作B，运行时，类C实例替换B，这样我们即可进行新类的扩展(继承类B或接口B)，同时无须对类A进行修改。

　　3. 依赖原则 (the Dependency Inversion Principle DIP)

　　在进行业务设计时，与特定业务有关的依赖关系应该尽量依赖接口和抽象类，而不是依赖于具体类。具体类只负责相关业务的实现，修改具体类不影响与特定业务有关的依赖关系。

　　在结构化设计中，我们可以看到底层的模块是对高层抽象模块的实现(高层抽象模块通过调用底层模块)，这说明，抽象的模块要依赖具体实现相关的模块，底层模块的具体实现发生变动时将会严重影响高层抽象的模块，显然这是结构化方法的一个"硬伤"。

　　面向对象方法的依赖关系刚好相反，具体实现类依赖于抽象类和接口。

　　为此，我们在进行业务设计时，应尽量在接口或抽象类中定义业务方法的原型，并通过具体的实现类(子类)来实现该业务方法，业务方法内容的修改将不会影响到运行时业务方法的调用。

　　4. 接口分离原则(the Interface Segregation Principle ISP)

　　采用多个与特定客户类有关的接口比采用一个通用的涵盖多个业务方法的接口要好。

　　ISP原则是另外一个支持诸如COM等组件化的使能技术。缺少ISP，组件、类的可用性和移植性将大打折扣。

　　这个原则的本质相当简单。如果你拥有一个针对多个客户的类，为每一个客户创建特定业务接口，然后使该客户类继承多个特定业务接口将比直接加载客户所需所有方法有效。

　　以上四个原则是面向对象中常常用到的原则。此外，除上述四原则外，还有一些常用的经验诸如类结构层次以三到四层为宜、类的职责明确化(一个类对
应一个具体职责)等可供我们在进行面向对象设计参考。但就上面的几个原则看来，我们看到这些类在几何分布上呈现树型拓扑的关系，这是一种良好、开放式的线
性关系、具有较低的设计复杂度。一般说来，在软件设计中我们应当尽量避免出现带有闭包、循环的设计关系，它们反映的是较大的耦合度和设计复杂化。

小公司如何做项目管理

2008-11-18T06:23:00.001-08:00

小公司如何做项目管理

http://www.javaeye.com/topic/216779

我所在的公司和大多数国内IT公司一样，十几到几十人的规模，每次在做完项目过程中我们都会感觉很累，老板其实也很累，在小公司老板更像是一个项目经理的角色，很多东西都没有流程化的东西可走，所以很多事情都要等老板拍板后才可以继续下去，员工在很多时候就会感到迷茫，随着公司规模的扩大，公司也意识到没有一套规范的项目管理方案是万万不行的，自己在这方面也摸索的一段时间。

我
首先接触的是敏捷开发的方法，但很快我就感觉这个方法行不通，至少对于我们是这样，因为我们无法保证和客户以及业务人员及时沟通，一个月见几次面就很不错
了，而且我们的开发人员也并不具有敏捷能力。后来接触了下CMMI，CMMI对于小公司就更不靠谱了，它庞大的身躯足以把一个小公司压垮，如果仅为一个证
书的话，我建议完全可以向o6z订购，但不可否认的是CMMI也有很多优秀的地方可以借鉴。那么我对小公司项目管理的看法是一定要精简，做到不是傻瓜都能
够理解并且能够执行，况且很多项目经理（老板）也并不是领域专家。在此我想简单谈谈我对适合小公司的项目管理方案的一些想法，所谓基本适合就是80%适合，我要是说100%适合那我是在扯淡，另外20%怎么办？那就像06z所说的那样，靠经验这个王道。

首先要谈的是需
求这个东西，那么什么是需求？需求就是掏钱买你产品的人一些需要，只要是客户的需要，不管是合理不合理那都是需求。其实很多开发人员都意识需求的重要性，
那么真正去做需求的人有多少呢？需求应该是包括需求开发和需求管理这两个过程，这里有个特别的情况是对于自主研发的项目，我接触的项目也是这种情况居多，于是我们认为自己就是客户，所以需求开发做的很简单甚至跳过去，结果后期的需求管理非常混乱，我觉得既然自己是客户，那就要当好客户这个角色，在做客户时应完全忘却自己是个开发人员，同样要把需求做全面。很多教科书上都说应该做需求，但关于怎么做的问题上却和实际情况差别比较大，以下是我关于需求该做什么以及怎么做到一些看法。

1 需求调研

我觉得需求调研非常的重要，1年前我还打算做一个在线教育服务平台，理念就是淘宝在网上卖商品，我在网上卖教育资源，我提供网上交易场所，签约的老师、学校以及培训机构提供可交易的服务，这种服务可以通过视频、音频、在线PPT、文本的形式展现。忙活了好一阵，发现这个市场早就有很多人做了，而且这个市场并不是很好做，首先在网上学习的人有几个？并且先不说前期推广需要海量资金就是所需要的那么些高性能服务器丫也买不起！这件事就此搁浅，结果信了马云的邪，2年后你还想
创业你在创业！我觉得这就是典型的需求调研没做好，没有对用户需求做调查，没有考虑同行竞争，没有考虑可行性！另外还要考虑括行业标准和法律规定，比如前
些时候国家就出台了关于办视频网站的政策，我觉得你丫没有足够的背景就不要往火坑里跳楼。总之根据所做行业情况尽可能的把需求调研做全面，这样才可以保证
项目首先是可以赚钱的。那么文档要写吗？我觉得可以不要正式的文档，小公司的人手本来就不够用，要把主要文档化工作集中在重要的环节上，对于需求调研，本来就很杂乱，完全可以记在工作笔记上，放到需求分析的时候整理。

2 需求分析

为了得到用户的金钱，我们总是在说，用户是上帝，用户永远是对的，尽管背地里在说客户端坏话：“你丫钱给的倒不多，要求还真少，这需求根本不合理，是正常人的逻辑吗？”，如果你想活下去，最终我们还是要想方设法满足用户的要求。用户是个外界因素，我们是无法控制的，
那么我们只有尽可能改进需求分析的方法来尽量减少不必要的麻烦。那么我觉得日本人做法倒是可以借鉴，在有条件的情况下派专人去现场，随时记录关键性的需
求，即使不能去现场也尽可能的获取尽可能多大信息，不要指望开发后去获取什么有价值的东西。那么是否应该做个原型给客户看看？我是觉得这不大合适，因为如
果项目周期短的话，等你做好原型，黄花菜都凉了。但我觉得等到需求做到差不多的时候可以做用户界面，所谓用户界面就是用户接口，是和用户打交道的地方，所
谓一图解千言，有了界面用户会清楚自己所买的东西在未来会是个什么样的东西，再者开发几个有说明性都界面倒是不会暂用很多时间。等到需求确定下来后就要整理成文档了，这个是很重要的一步，是做设计时候的重要凭证和依据，这个文档就是用户规格说明书，所谓规格就是有规范的格式和内容。

3 需求评审

我
们已经有了较正规的文档了，那么下一步就是召集所有开发人员开会，最好有客户代表参加，尽管我是很厌烦开会，但该开的会还是要开到，因为之前我遇到这种情
况，开发人员根据设计文档写代码，可是他并不知道自己在开发什么，站在自己的角度想一下，如果自己都不确定自己做的东西，即使有再完备的设计，也会对开发
毫无兴趣，只会让自己觉得自己是个代码机器。所以所有人员参加需求评审是让大家知道自己在做一件有意义的事情，自己正在满足社会的需要，自己在为和谐社会
做贡献，即使你从没那么想过，那你敢保证的你的潜意识没那么想过吗？人是要有社会满足感的吧。另外开会前一定要准备关键有价值的议题，据我观察需求评审会
最容易扯到不着边的话题，所以主持人要控制话题，会议控制在2-3个钟头，最好做成幸运52的形式，所有人员一定要互动起来，否则就变成了个人演讲。需求也做了，会也开了，那么要求客户签字吧。

4 需求管理

需求管理是在开发开始之后进行的，这也是另所有人头疼的一件事，之前做完一个项目后，客户经常打电话找我们，改过来改过去，后来我听到电话，血压都要升高50个百分点，后来索性就不接电话，客户就在网上找我，搞的我连QQ都不敢登，但躲是躲不掉滴，客户直接打我手机，丫的真烦人，见过难缠的，没见过这么难缠的。后来转念一想，难道这种情况真的不能避免吗？至少是可以大幅度的缓解的吧。这就是我们需求管理中的变更管理没做好，改了哪些地方自己都忘记了，最后是跟着感觉走，拆东墙补西墙。在
这里我建议要建立需求跟踪矩阵表，有了这个表我们至少可以对要修改的地方有了依据，迫使我们去调查到底是改什么地方，怎么改，最后改成了什么样。可能你会
说客户需要大幅度修改原有计划，很难跟踪到具体某一项需求，那么我觉得这是由于前期的需求开发没有做好，在后期客户进行实质性的修改的几率是很小的，比如
客户要求我们做个OA系统，最后总不会要我们改成个门户网站吧，在举个例子，在比如你开发一个ERP系统，客户自己的业务流程不会轻易的改变吧，总不至于
把盘点这个业务改成一个报表系统吧。如果真是这样，我们完全有理由告诉客户，你丫乖乖掏银子，我们再给你们开发2期工程，要改，没门！

大家开始拍砖吧，有时间继续……

很多东西说不清楚. 就需求管理本身,在我们这种环境里面就说不清楚了. 如果直接跳到后面, 当然会死得更惨. 可如何走好第一步呢? 需求跟踪矩阵如何用呢? 呵呵.... 看的都晕.

我之前的想法和你一样，由于很多东西说不清，所以干脆不说，所以我们逃避，可是需求管理是躲不了的，否则就像你说的死得更惨，我也想听听你更好的建议：），就像牛根生所说的，办法总比问题多。

需求管理难做和做不做是2回事，我觉得只要你认真去做，总会有收获，需求跟踪矩阵怎么用？那要看你要怎么用，变更总要有原因吧，针对变更总得有解决措施吧，你的后续修改工作总得有个依据吧，修改完之后总得有个结果记录吧，附上需求变更表一份。

在上篇文章里，我简要谈了项目管理中的需求开发和管理，那么在这篇文章里就和各位以闲话家常的方式讨论下项目规划和项目监控。项目规划、项目监控其实也是项目管理中比较核心的工作，也是很多开发人员最敏感的话题，因为这两个东西与公司的领导和员工关系都非常的密切。

先从我以前的学校说起，以前我们学校有片荒地，当时的领导觉得学校应该搞绿化，于是组织在荒地上植树，不到一年换了一个校长，这位校长觉得学校应该抓体育
运动，决定再造一个足球场，于是把树移走，造了一个足球场，再后来北京奥运会来了，学习为了迎合绿色奥运的理念又开始植树，这就是没有规划和监控的典型例
子，结果是劳民又伤财。当然对于学校来说，有国家财政的支持，有资本这么折腾，可是对于小公司做项目来说，这么折腾几下估计很快就要牺牲了。

事实求是的说大多数小公司在这两个方面做得很少有令人的满意的，小公司的老板其实也会意识到公司在项目规划和监控方面做得不咋地，但很少能做到有效的改
进，其实这个也是有很多方面的原因的，以我自作多情的猜测主要有以下两个原因，对于小公司，尽管盈利不是很多，但基本还是可以撑下去的，老板会觉得管他乱
不乱，公司总之每个月还是有盈利的，少就少点吧，多干几年自己的下半辈子基本有别墅有车了，所以比较保守，要是改革吧，万一鸡飞蛋打怎么办？还是本分点
好，小心使得万年船。其实是对项目规划和监控其实需要大量的成本，老板觉得钱应该花在刀刃上，搞这些东西就是在务虚。再者更恶劣的老板有病就乱烧香，就有
想想借助CMMI这个洋玩意治病的，其实很多老板都蛮喜欢CMMI的，CMMI就是假定人就是一个机器的部件，可以替换可以不停的运转，总之管机器总比管
人省心吧，结果是万分的矛盾，银子撒了一大把，收效却甚微，甚至比以前更乱，大家做的都不开心。与其听咨询师们拿什么高深的方法论来瞎掰，不如我们谈点实
际的，想就以下议题来和各位消遣。

1 工作量估算

对于工作量估算很多项目经理（老板）喜欢用数学公式来计算，可能数学公式更加的客观和科学，ok,，看看市面流行的计算方法吧，最常见的是基于代码行的数
学模型，那么这里存在不少问题，工作量估算主要是为了在项目进行中进行有效的项目监控，那么软件开发尚未结束，谁知道最后的代码行有多大？代码经常会被修
改，那么修改的代码算不算？如果算，那么代码修改越多难道能说明工作量越大？代码效率的区别也是很大的，假如一个10行代码可以实现的东西被写成50行，
难道能客观的反映工作量？还有2种比较高级点的方法是基于功能点和COCOMO的方法，那么我想问的是它们的公式中的系数该怎么定？那么不少咨询师忽悠我
说，根据自己的实际情况来定呗，那么我想问的是，算命是迷信，电脑意味着科学，那么用电脑算命算不算迷信?所以我是主张这里还是要靠人的经验来估算，大家
可以在项目周会上对工作量进行充分的估算，在估算时要同时考虑到项目执行的难度，根据经验给出合理的评估。

2 任务分配

大多数的做法是将整个项目划分成一个个可以独立执行的原子任务，这些任务要划分优先级和难度，至少心理有个数，并且每项任务要制定负责人。那么问题就出在
这个任务分配上了，软件开发是一项智力创造的活动，如果按CMMI假设的那样，在分配任务时忽略人的因素是万万不可取的，我就有血的教训，不久之前做一个
ruby的项目，然后开始在公司内部随便抓了几个有点ruby基础的人，也没太顾忌别人的想法。做着做着，觉得他们有点心在曹营心在汉，平时还是抱着本
thinking in java看，做ruby也是在敷衍了事，结果是代码质量不行，需要大规模的修改。当然按理说员工应该服从公司的安排，做一样就要
做好一样，但员工也有员工的规划，你去叫他做他压根就不喜欢的事只能说明管理有问题。

另外还有一个普遍性的问题是能者多劳，有个朋友刚进公司动手能力很强，也非常的积极，每次做项目都分给他最难最累的任务，做着做着也就厌倦了，这时老板会
忽悠你说，你能力强，要挑起公司的大梁，以后公司壮大了给你个什么职位，我觉得这就是在扯淡，这就是我经常见到的忽悠式的管理，很多管理手段完全靠人情，
很多人都是在这种环境中被忽悠长大，到最后怎么样？被忽悠了几年还不是另谋高就了，所以指望人情化管理的公司很难长大。我觉得该讲原则的地方就要讲原则，
在任务分配上给能力强的分配少而精的任务，而且要考虑到员工自己的想法，有些人想做java架构师，你叫他做oracle dba就不合适，有些对ui设
计感兴趣，你叫他做系统分析员也不合适，有些人就喜欢搞技术，你硬要叫他做管理也是不合适。

3 进度管理

在做进度之前，一项最重要的任务是识别关键任务，很多进度表进行任务安排时将各项任务平均分的特点为觉得极不合适，有些任务比较难处理，而且许多后续任务
依赖于该项任务，那么这项任务就应该配备更精良的人手和充裕的时间，依我的经验80%的时间都是在处理这些20%的关键任务上。这里还有个比较重要的问题
是时间安排，我听很多项目经理说时间安排要尽可能的紧，也就是比预计要靠前，这样员工才有紧迫感。我觉得这是不可取的，首先即使你按原计划进行，八成也是
要要延期的，那么这就会导致项目严重延期，长此以往，项目延期成了家常便饭，不延期反而不正常，于是大家都成了老油条，那么进度表不就是废纸一张，毫无约
束力而言吗！我觉得根据实际情况指定个合理的进度表是比较重要的，或许你会说项目还是在延期，那我觉得是你项目估算没有做好，项目延期在10%左右比较正
常，否则就可以调查是什么原因导致进度滞后，如果是客观原因，以后完全可以延长项目时间，总之一个合理的进度表比较重要。

4 项目奖金

这里牵扯到一个钱的问题，据我了解国内大多小公司很少有项目奖金这么一说，年底给点路费就不错了！国内的大多数项目经理更像是一个技术负责人，根本没有用
钱的权利，我就曾像公司申请项目奖金，结果计划全盘泡汤，给的理由很荒唐，说项目奖金不好分配，给张三多一点吧，李四不爽，反之亦然。我心理暗自想：“你
丫不想给就直说呗！”，这里会导致一个问题，就是“项目经理”凭什么约束成员，大锅饭的道理我也不想再解释了，总之结果就是3个月的项目就得做个5个月，
其实老板的小算盘看似很精明，其实未见得，虽然项目奖金能省就省了，那么工作效率的下降所带来的成本的提高，孰轻孰重？长远一点说，产品质量的下滑导致的
项目维护的成本你计算过吗？依我的经验，3个月的有效工作时间其实也就是1个月，这已经不错了。不过项目奖金的分配确实是个难问题，但有没有项目奖金和分
配合理与否是2码子事吧？由于我也没有能耐申请到项目奖金所以也就没有深入研究这个问题，只得望梅止渴，看看人家华为了，员工根据能力分等级，加上年限、
加班、表现得出个权值来计算。总之现有鸡才能有蛋，这个问题需要更深入的讨论。

先写那么多，有时间继续……

URL重写

2008-11-18T06:22:00.003-08:00

Apache伪静态html(URL Rewrite)设置法

2007-02-12 10:41作者：出处：天极网责任编辑：龙犊

一打开 Apache 的配置文件 httpd.conf 。
二将#LoadModule rewrite_module modules/mod_rewrite前面的#去掉
三在 httpd.conf中添加：
<IfModule mod_rewrite.c>
    RewriteEngine On
    #RewriteCond %{ENV:SCRIPT_URL} (?:index|dispbbs)[-0-9]+\.html
    RewriteRule ^(.*?(?:index|dispbbs))-([-0-9]+)\.html$ $1.php?__is_apache_rewrite=1&__rewrite_arg=$2
</IfModule>

四要实现asp帖子URL到php帖子的映射，在第三步的<IfModule mod_rewrite.c>和</IfModule>之间添加：
    RewriteMap tolowercase int:tolower
    RewriteCond %{QUERY_STRING} (?:boardid|page|id|replyid|star|skin)\=\d+ [NC]
    RewriteRule ^(.*(?:index|dispbbs))\.asp$ $1.php?${tolowercase:%{QUERY_STRING}}&__is_apache_rewrite=1

五保存httpd.conf并重启Apache。

Url Rewrite Filter 是一个基于java的 URL rewrite 一个包。使用它后就可以使用一些友好的URL来代替 ?&组成的URL了。例如可以把 http://www.cngump.com/world/china/guangzhou 转换为 http://www.cngump.com/world.jsp?country=china&city=guangzhou

步骤如下：

1. 下载和安装 Tomcat

2. 部署一个空白的 Java Web Application. urlrewrite.war

3. 下载 Url Rewrite Filter http://tuckey.org/urlrewrite/

4. 解压下载后的 urlrewritefilter-2.6.zip 到 TOMCAT_HOME\webapps\urlrewrite\ 下

5. 修改 web.xml 如下

   ＜?xml version=”1.0″ encoding=”UTF-8″?＞

＜web-app id=”WebApp_9″ version=”2.4″ xmlns=”http://java.sun.com/xml/ns/j2ee”

         xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”

         xsi:schemaLocation=”http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd“＞

＜display-name＞Url Rewrite＜/display-name＞

    ＜filter＞

        ＜filter-name＞UrlRewriteFilter＜/filter-name＞

        ＜filter-class＞org.tuckey.web.filters.urlrewrite.UrlRewriteFilter＜/filter-class＞

    ＜/filter＞

    ＜filter-mapping＞

        ＜filter-name＞UrlRewriteFilter＜/filter-name＞

        ＜url-pattern＞/*＜/url-pattern＞

    ＜/filter-mapping＞

＜/web-app＞

6. 在更目录新建一个 world.jsp 文件。代码如下：

＜html＞

＜header＞

＜title＞world＜/title＞

＜/header＞

＜body＞

＜%

        String country = request.getParameter(”country”);

        String city = request.getParameter(”city”);

        out.write(”Country=” + country);

        out.write(”＜br＞city=” + city);

    %＞

＜/body＞

＜/html＞

7. 修改 WEB-INF 下的 urlrewrite.xml: (使用正则式进行解释)

＜urlrewrite＞

＜rule＞

＜from＞/world/([0-9]+)/([0-9]+)＜/from＞

＜to＞/world.jsp?country=$1&city=$2＜/to＞

＜/rule＞

＜/urlrewrite＞

8. 重新加载 urlrewrite 后测试:

http://localhost:8080/urlrewrite/world/china/guangzhou

和http://localhost:8080/urlrewrite/world.jsp?country=china&city=guangzhou效果一样

Acegi框架介绍

2008-11-18T06:22:00.001-08:00

Acegi框架介绍

概述
    【IT168 专稿】对于任何一个完整的应用系统，完
善的认证和授权机制是必不可少的。Acegi
Security（以下简称Acegi）是一个能为基于Spring的企业应用提供强大而灵活安全访问控制解决方案的框架，Acegi已经成为
Spring官方的一个子项目，所以也称为Spring
Security。它通过在Spring容器中配置一组Bean，充分利用Spring的IoC和AOP功能，提供声明式安全访问控制的功能。虽然，现在
Acegi也可以应用到非Spring的应用程序中，但在Spring中使用Acegi是最自然的方式。
Acegi可以实现业务对象方法级的安全访问控制粒度，它提供了以下三方面的应用程序的安全：

? URL资源的访问控制
    如所有用户（包括其名用户）可以访问index.jsp登录页面，而只有授权的用户可以访问/user/addUser.jsp页面。Acegi允许通过正则表达式或Ant风格的路径表达式定义URL模式，让授权用户访问某一URL匹配模式下的对应URL资源。

? 业务类方法的访问控制
    Spring容器中所有Bean的方法都可以被Acegi管理，如所有用户可以调用BbtForum#getRefinedTopicCount()方法，而只有授权用户可以调用BbtForum#addTopic()方法。

? 领域对象的访问控制

业务类方法代表一个具体的业务操作，比如更改、删除、审批等，业务类方法访问控制解决了用户是否有调用某种操作的权限，但并未对操作的客体（领域对象）进
行控制。对于我们的论坛应用来说，用户可以调用BbtForum#updateUser(User
user)方法更改用户注册信息，但应该仅限于更改自己的用户信息，也即调用BbtForum#updateUser()所操作的User这个领域对象必
须是受限的。

    Acegi通过多个不同用途的Servlet过滤器对URL资源进行保护，在请求受保护的URL资源前，Acegi的Servlet过滤器判断用户是否有权访问目标资源，授权者被开放访问，而未未被授权者将被阻挡在大门之外。
    Acegi通过Spring AOP对容器中Bean的受控方法进行拦截，当用户的请求引发调用Bean的受控方法时，Acegi的方法拦截器开始工作，阻止未授权者的调用。


对领域对象的访问控制建立在对Bean方法保护的基础上，在最终开放目标Bean方法的执行前，Acegi将检查用户的ACL（Aeccess
Control
List：访问控制列表）是否包含正要进行操作的领域对象，只有领域对象被授权时，用户才可以使用Bean方法对领域对象进行处理。此外，Acegi还可
以对Bean方法返回的结果进行过滤，将一些不在当前用户访问权限范围内的领域对象剔除掉——即传统的数据可视域范围的控制。一般来说，使用Acegi控
制数据可视域未非理想的选择，相反通过传统的动态SQL的解决方案往往更加简单易行。


从本质特性上来说，Servlet过滤器就是最原始的原生态AOP，所以我们可以说Acegi不但对业务类方法、领域对象访问控制采用了AOP技术方案，
对URL资源的访问控制也使用了AOP的技术方案。使用AOP技术方案的框架是令人振奋的，这意味着，开发者可以在应用程序业务功能开发完毕后，轻松地通
过Acegi给应用程序穿上安全保护的“铁布衫”。
Acegi体系结构

乘飞机前需要通过安检，乘客必须提供身份证以验证其身份。在通过安检进入候机室后，国航、海航、南航等不同航空公司的飞机陆续到达，但你只能登上机票上对
应航班的飞机。在登机后，只能坐在机票对应的座位上——你不能抢占他人的座位，你不能在座位上刻字留念、你不能要求空姐打开机窗……

    乘飞机的过程最能体现安全控制的流程，我们可以从中找到身份认证、资源访问控制、领域对象安全控制的对应物：安检对应身份认证，登机对应资源访问控制而按号就座则对应领域对象安全控制。
    Acegi通过两个组件对象完成以上安全问题的处理：AuthenticationManager（认证管理器）、AccessDecisionManager（访问控制管理器），如图 1所示：

图 1 Acegi体系结构

SecurityContextHolder是框架级的容器，它保存着和所有用户关联SecurityContext实
例，SecurityContext承载着用户（也称认证主体）的身份信息的权限信息，
AuthenticationManager、AccessDecisionManager将据此进行安全访问控制。


SecurityContext的认证主体安全信息在一个HTTP请求线程的多个调用之间是共享的（通过ThreadLocal），但它不能在多个请求之
间保持共享。为了解决这个问题，Acegi将认证主体安全信息缓存于HttpSession中，当用户请求一个受限的资源时，Acegi通过
HttpSessionContextIntegrationFilter将认证主体信息从HttpSession中加载到
SecurityContext实例中，认证主体关联的SecurityContext实例保存在Acegi容器级的
SecurityContextHolder里。当请求结束之后，HttpSessionContextIntegrationFilter执行相反的操
作，将SecurityContext中的认证主体安全信息重新转存到HttpSession中，然后从SecurityContextHolder中清
除对应的SecurityContext实例。通过HttpSession转存机制，用户的安全信息就可以在多个HTTP请求间共享，同时保证
SecurityContextHolder中仅保存当前有用的用户安全信息，其整体过程如图 2所示：

图 2 SecurityContext在HttpSession和请求线程间的转交过程

当用户请求一个受限的资源时，AuthenticationManager首先开始工作，它象一个安检入口，对用户身份进行核查，用户必须提供身份认证的
凭证（一般是用户名/密码）。在进行身份认证时，AuthenticationManager将身份认证的工作委托给多个
AuthenticationProvider。因为在具体的系统中，用户身份可能存储在不同的用户信息安全系统中（如数据库、CA中心、LDAP服务
器），不同用户信息安全系统需要不同的AuthenticationProvider执行诸如用户信息查询、用户身份判断、用户授权信息获取等工作。只要
有一个AuthenticationProvider可以识别用户的身份，AuthenticationManager就通过用户身份认证，并将用户的授
权信息放入到SecurityContext中。

当用户通过身份认证后，试图访问某个受限的程序资源时，AccessDecisionManager开始工作。
AccessDecisionManager采用民主决策机制判断用户是否有权访问目标程序资源，它包含了多个AccessDecisionVoter。
在访问决策时每个AccessDecisionVoter都拥有投票权，AccessDecisionManager统计投票结果，并按照某种决策方式根
据这些投票结果决定最终是否向用户开放受限资源的访问。

重要组件类介绍
    每个框架都有一些核心的概念，这些概念被固化为类和接口，成为框架的重要组件类。框架的管理类、操作类都在这些组件类的基础上进行操作。在进入Acegi框架的具体学习前，有必要事先了解一下这些承载Acegi框架重要概念的组件类。
    首先，我们要接触是UserDetails接口，它代表一个应用系统的用户，该接口定义了用户安全相关的信息，如用户名/密码，用户是否有效等信息，你可以根据以下接口方法进行相关信息的获取：
    String getUsername()：获取用户名；
     String getPassword()：获取密码；
     boolean isAccountNonExpired()：用户帐号是否过期；
     boolean isAccountNonLocked()：用户帐号是否锁定；
    boolean isCredentialsNonExpired()：用户的凭证是否过期；
    boolean isEnabled()：用户是否处于激活状态。
    当以上任何一个判断用户状态的方法都返回false时，用户凭证就被视为无效。

UserDetails还定义了获取用户权限信息的方法：GrantedAuthority[]
getAuthorities()，GrantedAuthority代表用户权限信息，它定义了一个获取权限描述信息（以字符串表示，如
PRIV_COMMON）的方法：String getAuthority()。

图 3 用户和权限

在未使用Acegi之前，我们可能通过类似User、Customer等领域对象表示用户的概念，并在程序中编写相应的用户认证的逻辑。现在，你要做的一
个调整是让原先这些代表用户概念的领域类实现UserDetails接口，这样，Acegi就可以通过UserDetails接口访问到用户的信息了。

UserDetails可能从数据库、LDAP等用户信息资源中返回，这要求有一种机制来完成这项工作，UserDetailsService正是充当这
一角色的接口。UserDetailsService接口很简单，仅有一个方法：UserDetails
loadUserByUsername(String username) ，这个方法通过用户名获取整个UserDetails对象。
Authentication代表一个和应用程序交互的待认证用户，Acegi从类似于登录页面、Cookie等处获取待认证的用户信息（一般是用户名密码）自动构造Authentication实例。

图 4 Acegi的认证用户

Authentication可以通过Object
getPrincipal()获取一个代表用户的对象，这个对象一般可以转换为UserDetails，从中可以取得用户名/密码等信息。在
Authentication被AuthenticationManager认证之前，没有任何权限的信息。在通过认证之后，Acegi通过
UserDetails将用户对应的权限信息加载到Authentication中。Authentication拥有一个
GrantedAuthority[] getAuthorities()方法，通过该方法可以得到用户对应的权限信息。

Authentication和UserDetails很容易被混淆，因为两者都有用户名/密码及权限的信息，接口方法也很类似。其实
Authentication是Acegi进行安全访问控制真正使用的用户安全信息的对象，它拥有两个状态：未认证和已认证。UserDetails是代
表一个从用户安全信息源（数据库、LDAP服务器、CA中心）返回的真正用户，Acegi需要将未认证的Authentication和代表真实用户的
UserDetails进行匹配比较，通过匹配比较（简单的情况下是用户名/密码是否一致）后，Acegi将UserDetails中的其它安全信息（如
权限、ACL等）拷贝到Authentication中。这样，Acegi安全控制组件在后续的安全访问控制中只和Authentication进行交
互。

由于Acegi对程序资源进行访问安全控制时，一定要事先获取和请求用户对应的Authentication，Acegi框架必须为Authentication提供一个“寓所”，以便在需要时直接从“寓所”把它请出来，作为各种安全管理器决策的依据。

SecurityContextHolder就是Authentication容身的“寓所”，你可以通过
SecurityContextHolder.getContext().getAuthenication()代码获取Authentication。
细心观察一下这句代码，你会发现在SecurityContextHolder和Authentication之间存在一个getContext()中
介，这个方法返回SecurityContext对象。SecurityContext这个半路杀出来的程咬金有什么特殊的用途呢？我们知道
Authentication是用户安全相关的信息，请求线程其它信息（如登录验证码等）则放置在SecurityContext中，构成了一个完整的安
全信息上下文。SecurityContext接口提供了获取和设置Authentication的方法：
 Authentication getAuthentication()
 void setAuthentication(Authentication authentication)

图 5 认证用户信息存储器

SecurityContextHolder是Acegi框架级的对象，它在内部通过ThreadLocal为请求线程提供线程绑定的
SecurityContext对象。这样，任何参与当前请求线程的Acegi安全管理组件、业务服务对象等都可以直接通过
SecurityContextHolder.getContext()获取线程绑定的SecurityContext，避免通过方法入参的方式获取用户
相关的SecurityContext。


线程绑定模式对于大多数应用来说是适合的，但是应用本身会创建其它的线程，那么只有主线程可以获得线程绑定SecurityContext，而主线程衍生
出的新线程则无法得到线程绑定的SecurityContext。Acegi考虑到了这些不同应用情况，提供了三种绑定SecurityContext的
模式：
 SecurityContextHolder.MODE_THREADLOCAL：SecurityContext绑定到主线程，这是默认的模式；
 SecurityContextHolder.MODE_GLOBAL：SecurityContext绑定到JVM中，所有线程都使用同一个SecurityContext；
 SecurityContextHolder.MODE_INHERITABLETHREADLOCAL：：SecurityContext绑定到主线程及由主线程衍生的线程中。
    你可以通过SecurityContextHolder.setStrategyName(String strategyName)方法指定SecurityContext的绑定模式。
用户认证过程
　　Acegi支持多种方式的用户认证：如典型的基于数据库的认证、基于LDAP的认证、基于Yale中心认证等方式。不同的认证环境拥有不同的用户认证方式，现在我们先抛开这些具体的细节，考察一下Acegi对受限资源进行访问控制的典型过程：
    1．你点击一个链接访问一个网页；
    2．浏览器发送一个请求到服务器，服务器判断出你正在访问一个受保护的资源；
    3．如果此时你并未通过身份认证，服务器发回一个响应提示你进行认证——这个响应可能是一个HTTP响应代码，抑或重定向到一个指定页面；
    4．根据系统使用认证机制的不同，浏览器或者重定向到一个登录页面中，或者由浏览器通过一些其它的方式获取你的身份信息（如通过BASIC认证对话框、一个Cookie或一个X509证书）；
    5．浏览器再次将用户身份信息发送到服务器上（可能是一个用户登录表单的HTTP POST信息、也可能是包含认证信息的HTTP报文头）；
    6．服务器判断用户认证信息是否有效，如果无效，一般情况下，浏览器会要求你继续尝试，这意味着返回第3步。如果有效，则到达下一步；
    7．服务器重新响应第2步所提交的原始请求，并判断该请求所访问的程序资源是否在你的权限范围内，如果你有权访问，请求将得到正确的执行并返回结果。否则，你将收到一个HTTP 403错误，这意味着你被禁止访问。
    在Acegi框架里，你可以找到对应以上大多数步骤的类，其中ExceptionTranslationFilter、AuthenticationEntryPoint、AuthenticationProvider以及Acegi的认证机制是其中的代表者。


ExceptionTranslationFilter是一个Acegi的Servlet过滤器，它负责探测抛出的安全异常。当一个未认证用户访问服务器
时，Acegi将引发一个Java异常。Java异常本身对HTTP请求以及如何认证用户是一无所知
的，ExceptionTranslationFilter适时登场，对这个异常进行处理，启动用户认证的步骤（第3步）。如果已认证用户越权访问一个资
源，Acegi也将引发一个Java异常，ExceptionTranslationFilter则将这个异常转换为HTTP
403响应码（第7步）。可见，Acegi通过异常进行通讯，
ExceptionTranslationFilter接收这些异常并作出相应的动作。


当ExceptionTranslationFilter通过Java异常发现用户还未认证时，它到底会将请求重定向哪个页面以要求用户提供认证信息呢？
这通过咨询AuthenticationEntryPoint来达到目的——Acegi通过AuthenticationEntryPoint描述登录页
面。


当你的浏览器通过HTTP表单或HTTP报文头向服务器提供用户认证信息时，Acegi需要将这些信息收集到Authentication中，Acegi
用“认证机制”描述这一过程。此时，这个新生成Authentication只包含用户提供的认证信息，但并未通过认证。
AuthenticationProvider
负责对Authentication进行认证。AuthenticationProvider究竟如何完成这一过程呢？请回忆一下上节我们所介绍的
UserDetails和UserDetailsService，大多数AuthenticationProvider通过
UserDetailsService获取和未认证的Authentication对应的UserDetails并进行匹配比较来完成这一任务。当用户认
证信息匹配时，Authentication被认为是有效的，AuthenticationProvider进一步将UserDetails中权限、
ACL等信息拷贝到Authentication。
当Acegi通过认证机制收集到用户认证信息并填充好Authentication后，Authentication将被保存到SecurityContextHolder中并处理用户的原始请求（第7步）。

    你完全可以抛开Acegi的安全机制，编写自己的Servlet过滤器，使用自己的方案构建Authentication对象并将其放置到SecurityContextHolder中。也许你使用了CMA（Container
Managed Authentication：容器管理认证），CMA允许你从ThreadLocal或JNDI中获取用户认证信息，这时你只要获取这些信息并将其转换为Authentication就可以了。
   安全对象访问控制

Acegi称受保护的应用资源为“安全对象”，这包括URL资源和业务类方法。我们知道在Spring
AOP中有前置增强、后置增强、异常增强和环绕增强，其中环绕增强的功能最为强大——它不但可以在目标方法被访问前拦截调用，还可以在调用返回前改变返回
的结果，甚至抛出异常。Acegi使用环绕增强对安全对象进行保护。
    Acegi通过AbstractSecurityInterceptor为安全对象访问提供一致的工作模型，它按照以下流程进行工作：
    1．从SecurityContext中取出已经认证过的Authentication（包括权限信息）；
    2．通过反射机制，根据目标安全对象和“配置属性”得到访问目标安全对象所需的权限；
    3． AccessDecisionManager根据Authentication的授权信息和目标安全对象所需权限做出是否有权访问的判断。如果无权访问，Acegi将抛出AccessDeniedException异常，否则到下一步；
4．访问安全对象并获取结果（返回值或HTTP响应）；
5． AbstractSecurityInterceptor可以在结果返回前进行处理：更改结果或抛出异常。
    Acegi称受保护的应用资源为“安全对象”，这包括URL资源和业务类方法。我们知道在Spring
AOP中有前置增强、后置增强、异常增强和环绕增强，其中环绕增强的功能最为强大——它不但可以在目标方法被访问前拦截调用，还可以在调用返回前改变返回
的结果，甚至抛出异常。Acegi使用环绕增强对安全对象进行保护。
Acegi通过AbstractSecurityInterceptor为安全对象访问提供一致的工作模型，它按照以下流程进行工作：     1．
从SecurityContext中取出已经认证过的Authentication（包括权限信息）；     2．
通过反射机制，根据目标安全对象和“配置属性”得到访问目标安全对象所需的权限；     3．
AccessDecisionManager根据Authentication的授权信息和目标安全对象所需权限做出是否有权访问的判断。如果无权访
问，Acegi将抛出AccessDeniedException异常，否则到下一步； 4．访问安全对象并获取结果（返回值或HTTP响应）；
5． AbstractSecurityInterceptor可以在结果返回前进行处理：更改结果或抛出异常。

图 6 AbstractSecurityInterceptor工作流程

安全对象和一般对象的区别在于前者通过Acegi的“配置属性”进行了描述，如“/view.jsp=PRIV_COMMON”配置属性就将“
/view.jsp”这个URL资源标识为安全对象，它表示用户在访问/view.jsp时，必须拥有PRIV_COMMON这个权限。配置属性通过
XML配置文件，注解、数据库等方式提供。安全对象通过配置属性表示为一个权限，这样，Acegi就可以根据Authentication的权限信息获知
用户可以访问的哪些安全对象。
根据安全对象的性质以及具体实现技术，AbstractSecurityInterceptor拥有以下三个实现类：
 FilterSecurityInterceptor：对URL资源的安全对象进行调用时，通过该拦截器实施环绕切面。该拦截器使用Servlet过滤器实现AOP切面，它本身就是一个Servlet过滤器；
 MethodSecurityInterceptor：当调用业务类方法的安全对象时，可通过该拦截器类实施环绕切面；
 AspectJSecurityInterceptor：和MethodSecurityInterceptor类似，它是针对业务类方法的拦截器，只不过它通过AspectJ实施AOP切面。

Acegi版本升级的一些重大变化

Acegi项目开始于2003年，Acegi团队在发布新版本时非常谨慎，在本书写作之时，Acegi最新版本为1.0.3。在此之前Acegi已经发布
了10多个预览版本，由于Acegi框架优异的表现，许多大型应用早在Acegi
1.0正式版本发布之前（2006年5月），就已经采用Acegi框架作为其安全访问控制的解决方案。

    在Acegi社区里，来自世界各地众多优秀的安全领域专家对Acegi的改进和发展献计献策，Acegi团队广泛听取并吸收各种有益的建议，将它们融入到Acegi的框架中，使Acegi成为构建在Spring基础上企业应用的首选安全控制框架。
Acegi 1.0.3版本相比于早期预览版本发生了很大的变化，对于需要进行Acegi版本的项目来说，了解这一变化特别重要。下面，我们列出Acegi的一些重大的升级更新：

包名的更新：在0.9.0及之前的版本中，Acegi采用net.sf.acegisecurity包名前缀，在1.0.0版本之后更改为
org.acegisecurity（Hibernate也走过相同的道路，好在Acegi在正式版本发布之时就完成了这种转变）；


ACL模块的调整：ACL模块发生了重大的调整，Acegi团队接收了社区大量关于ACL模块的反馈意见，重新设计了ACL模块的底层结构，在性能、封装
性、灵活性上得到了质的提升。事实上，Acegi使用org.acegisecurity.acls包代替了原来的
org.acegisecurity.acl包，后者将在后期的版本中删除，由于这种伤筋动骨的变化，将很难兼容原来ACL模块。不过，目前基于新框架的
ACL模块还没有进行充分的测试，Acegi承诺在1.1.0版本发布时提供最终的实现；


删除了ContextHolder及其相关类：在Acegi
0.9版本中，ContextHolder及其相关类被彻底从Acegi项目中删除。ContextHolder可以在多个HTTP请求中共享同一个
ThreadLocal，这和Spring提倡的ThreadLocal只应在同一线程中共享相悖。现在，Acegi使用
SecurityContextHolder替换ContextHolder，它的生命周期是一个HTTP 请求；


使用FilterChainProxy同时代理多个过滤器：在早期的版本中，Acegi通过FilterToBeanProxy将web.xml中的
Servlet过滤器定义转移到Spring容器中。这比直接在web.xml中配置Servlet过滤器要方便一些，但是Acegi框架往往需要定义多
个Servlet过滤器，使web.xml配置文件变得冗长难看。在Acegi
0.8版本中提供FilterChainProxy，它可以同时代理多个Servlet过滤器并保证过滤器的顺序。因此在新版本
中，FilterChainProxy成为推荐的选择。

    小结

Acegi是Spring项目下一个成熟的安全访问控制框架，它允许利用了Spring
IoC的AOP的功能完成安全对象的访问控制。在Acegi框架中，SecurityContextHolder处于非常核心的位置，它是存放认证管理器
用户安全信息SecurityContext的“容器”，SecurityContext保存着用户安全访问控制所需的信息，直接被访问决策管理器使用。
HttpSessionContextIntegrationFilter通过在SecurityContextHolder和HttpSession中
摆渡SecurityContext，使多个请求线程可以共享同一个SecurityContext。

使用Acegi进行身份认证（之一）

2008-11-18T06:21:00.003-08:00

使用Acegi进行身份认证（之一）

【IT168 技术文档】概述

Acegi是专门为Spring Web应用提供安全保护的开源框架，它通过配置的方式就可以对业已存在的应用实施安全控制。在Acegi实施安全控制之前，必须获取操作者的身份，并进一步获知用户的权限，这样Acegi才可能对应用资源实施安全控制。在本文中，我们将介绍Acegi如何对操作者进行身份认证的内容。

将Acegi集成到Web应用程序中

Acegi
通过多个不同用途的Servlet过滤器截取HTTP请求，实施访问安全的控制。按照传统的方式，我们应该在web.xml配置文件中通
过<filter>定义Servlet过滤器并使用<filter-mapping>元素定义过滤器对应的URL匹配模式。

由于这些过滤器需要Spring容器中其它Bean的支持完成访问权限控制，最原始的方式是在过滤器中通过硬编码的方式访问Spring容器中的Bean：

WebApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(servletContext);
FooBean foo = (FooBean)ctx.getBean(“foo”);

这种硬编码的方式显然不太方便，如何让过滤器既能够正确工作又能享受到Spring IoC的好处呢？Acegi通过“过滤器代理”来解决这个问题。

代理Acegi的过滤器

org.acegisecurity.util.FilterToBeanProxy
使用Spring容器中的Bean代理过滤器，FilterToBeanProxy是一个标准的Servlet过滤器。在内部
FilterToBeanProxy通过WebApplicationContext访问Spring容器，并将过滤器处理逻辑委托给一个Spring容
器中的Bean。这样，我们就可以在web.xml中定义FilterToBeanProxy，声明过滤器匹配的URL模式，并在Spring容器中充分
利用IoC进行定义委托的Bean。

FilterToBeanProxy支持两个初始化参数：

l
targetClass：委托Bean的全限定类名，委托类必须实现过滤器接口。你必须在Spring容器中至少定义一个该类的Bean，否则将抛出异
常。当Spring容器中拥有多个该委托类的Bean时，FilterToBeanProxy选择第一个委托类的Bean（这种情况应该避免）；

l targetBean：当然你也可以通过一个Bean名指定委托的Bean。
图 1说明了Acegi是如何通过FilterToBeanProxy将Servlet容器和Spring容器结合起来共同定义一个功能齐备的Servlet过滤器的：
图 1 通过过滤器代理将Servlet容器和Spring容器结合起来

org.acegisecurity.securechannel.ChannelProcessingFilter
是一个Acegi的过滤器，它负责处理安全通道的转换。如果直接在web.xml中定义ChannelProcessingFilter，我们将很难在不
编写代码的情况下，使其引用Spring容器中的Bean。借助FilterToBeanProxy的帮助，我们就可以放心地在Spring容器中配置
ChannelProcessingFilter，得到一个完整可用实例。当然ChannelProcessingFilter是需要服务于特定URL请
求的，而过滤器URL映射只能在Servlet容器的web.xml中定义，这个工作由FilterToBeanProxy对应的<filter-
mapping>元素完成。

如果我们将Servlet容器和Spring容器比作牛郎和织女，那么
FilterToBeanProxy无疑就是鹊桥了。事实上，Acegi本身并不依赖于FilterToBeanProxy，它是一种充分利用
Spring容器依赖注入好处配置Servlet过滤器的一个方法，正因为如此，所以Acegi社区中有很多开发者建议
FilterToBeanProxy应该从Acegi中剥离出来，将其加入到Spring的核心类库中。

使用代理过滤器链对处理HTTP请求

Acegi通过众多的过滤器完成不同安全控
制的任务，在前面我们提到了三个过滤器：HttpSessionContextIntegrationFilter、
ExceptionTranslationFilter和ChannelProcessingFilter。除此以外，还有LogoutFilter、
AuthenticationProcessingFilter等不下10个的过滤器。

当需要配置多个Servlet过滤器时，虽然
我们可以通过FilterToBeanProxy分别进行配置，但这将导致冗长难看的web.xml，同时还需要小心谨慎地通过过滤器的配置顺序保证它们
的调用顺序。为了解决这个问题，Acegi在0.8版本中添加了一个org.acegisecurity.util.FilterChainProxy。
FilterChainProxy可以同时指定多个过滤器并将它们组成一个过滤器链，而FilterToBeanProxy只要将代理目标设置为
FilterChainProxy就可以了。来看下面的配置：

代码清单 1 web.xml

<web-app>
<context-param> ①指定Spring配置文件
<param-name>contextConfigLocation</param-name>
<param-value>
classpath:applicationContext.xml,
classpath:applicationContext-acegi-plugin.xml
</param-value>
</context-param>
<filter>②将过滤器委托给FilterChainProxy
<filter-name>AcegiFilterChainProxy</filter-name>
<filter-class>
org.acegisecurity.util.FilterToBeanProxy
</filter-class>
<init-param>
<param-name>targetClass</param-name>
<param-value>
org.acegisecurity.util.FilterChainProxy
</param-value>
</init-param>
</filter>
<filter-mapping>③对所有的URL进行过滤
<filter-name>AcegiFilterChainProxy</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
…
</web-app>

在web.xml中我们首先需要定义Spring的配置文件，以便将Spring容器集成到Servlet容器中。紧接着，我们定义一个
FilterToBeanProxy的过滤器拦截所有URL请求并委托给FilterChainProxy进行处理。FilterChainProxy在
Spring容器中定义如下所示：

代码清单 2 applicationContext-acegi-plugin.xml

<beans>
<bean id="filterChainProxy" class="org.acegisecurity.util.FilterChainProxy">①目标委托的Bean
<property name="filterInvocationDefinitionSource">
<value>
CONVERT_URL_TO_UPPERCASE_BEFORE_COMPARISON
PATTERN_TYPE_APACHE_ANT
②多个过滤器组成的过滤器链
/**=channelProcessingFilter,httpSessionContextIntegrationFilter,logoutFilter
</value>
</property>
</bean>
<bean id="channelProcessingFilter" ③过滤器链中的过滤器(1)
class="org.acegisecurity.securechannel.ChannelProcessingFilter">
…
</bean>
<bean id="httpSessionContextIntegrationFilter" ④过滤器链中的过滤器(2)
class="org.acegisecurity.context.HttpSessionContextIntegrationFilter">
…
</bean>
…
</beans>

在①处定义的FilterChainProxy
Bean是web.xml的FilterToBeanProxy的委托目标。FilterChainProxy通过
filterInvocationDefinitionSource定义多个相互链接的过滤器，如②所示。这些过滤器以逗号分隔，它表示web.xml中
定义的匹配URL(/*)请求将分别通过channelProcessingFilter、
httpSessionContextIntegrationFilter及logoutFilter这三个过滤器的拦截处理。这个过滤器链通过过滤器对
应的Bean名字（如③和④）进行定义，过滤器都实现了javax.servlet
.Filter接口。你完全可以参照实例方式定义多组滤器链，以便处理不同URL请求。不过，在一般情况下，你只要配置一个过滤器链就可以了。

filterInvocationDefinitionSource属性由两类信息组成：其一是指令信息，如

CONVERT_URL_TO_UPPERCASE_BEFORE_COMPARISON
表示判断URL匹配时，首先将URL转变为大写的格式，如果设置为
CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON则表示比较前事先转换为小写的形式。而
PATTERN_TYPE_APACHE_ANT表示使用Ant路径风格进行匹配URL的描述，如果不提供这个指令，Acegi使用正则表达式来解析
URL路径映射。

身份认证管理

使用Acegi保护应用程序的第一步是根据用户提供的认证信息进行身份认证，以确定用户的身份，获取对应的权限信息，准备好Authentication。通过认证的Authentication拥有权限信息，它是Acegi进行后续安全对象访问安全控制的依据。

Acegi
对所有类型安全对象的访问控制机制基本相同：判断Authentication是否已经包含访问安全对象所需的权限。但Acegi进行身份认证的方式则多
姿多彩、五花八门，身份认证方式的多样性源于认证系统的多样性。由于篇幅所限，不可能面面俱到的逐一讲解所有的认证方式，我们将以最常见的基于数据库的认
证方式并对其它的认证方式进行简单的概述。

基于内存存储用户信息的身份认证

如果你开发的系统仅有少数几个固定的用户，且用户信息管理的功能很简单，这时你可以将用户直接保存在配置文件中，在系统启动将使用户信息常驻于内存中。下面，我们就从这个最简单的身份认证方式出发开始学习Acegi实际应用的征程。
代码清单 3 applicationContext-acegi-plugin.xml
身份认证过滤器

<beans>
<bean id="filterChainProxy" class="org.acegisecurity.util.FilterChainProxy">
<property name="filterInvocationDefinitionSource">
<value>
…
/**=authenticationProcessingFilter ①使用认证处理过滤器处理匹配的URL
</value>
</property>
</bean>
<bean id="authenticationProcessingFilter" ②认证处理过滤器
class="org.acegisecurity.ui.webapp.AuthenticationProcessingFilter">
②-1过滤器处理的URL
<property name="filterProcessesUrl" value="/j_acegi_security_check"/>
<property name="defaultTargetUrl" value="/main.jsp"/> ②-2认证成功后转向的URL
②-3认证失败后转向的URL
<property name="authenticationFailureUrl" value="/index.jsp?login_error=1"/>
</bean>
</beans>

首先，在①处通过FilterChainProxy定义了仅包含一个authenticationProcessingFilter的过滤器链。这
个过滤器链匹配于所有URL的请求，换句话说，authenticationProcessingFilter有机会对所有URL请求进行拦截处理，而在
这所有这些URL请求中，究竟哪个URL请求才是用户身份认证的请求呢？如果你心中也拥有这个疑问，则说明你正走在正确的理解问题的思路上。

authenticationProcessingFilter
在②-1、2、3处，定义了一些URL，它们分别对应身份认证请求的URL、认证成功后转向的URL以及认证失败后转向的URL。其中②-1处的
filterProcessesUrl属性表示这个URL是用户提交身份信息并要求进行身份认证的HTTP请求（一般是一个包含用户名/密码的表单
HTTP
POST请求），“/j_acegi_security_check”是默认的设置，之所以在此显式给出设置值，是为了说明你可以根据实际需要进行调整。

现在，authenticationProcessingFilter已经知道了申请进行用户身份认证URL，但它如何知道这个HTTP
请求分别通过什么参数代表用户名和密码呢？Acegi框架规定必须使用j_username和j_password作为用户名和密码的HTTP参数名。这
两个参数名是固定的，Acegi不允许对此进行配置，不过这种约定俗成而非事事配置的风格正渐渐成为流行的设计模式。

我们来看一下提供用户名/密码输入表单的登录页面：
代码清单 4 index.jsp：登录页面

<%@ page contentType="text/html;charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<html>
<body>
<c:if test="${not empty param.login_error}"> ①
<font color="red">用户名或密码错误。</font>
</c:if>
②处理用户身份认证服务所对应的URL
<form name="form1" method="post" action="<c:url value="/j_acegi_security_check"/>">
用户名：<input type="text" name="j_username"/><br/>③用户名的参数名
密 码：<input type="password" name="j_password"/><br/>④用户密码的参数名
<input type="submit" value="登录"/>
</form>
</body>
</html>

②处对应代码清单
3中②-1处的设置值，它表示处理用户身份认证服务所在的URL，而③和④是Acegi规定的承载用户名、密码的参数名。当这个表单提交后
authenticationProcessingFilter将从请求中抽取j_username和j_password参数的值，两者组成了代表请求
认证的用户信息，Acegi使用这个信息构造Authenticaion实例，并封装成SecurityContext放入到
SecurityContextHolder中，然后启动用户身份认证的流程。当认证成功后，页面转向代码清单
3中②-2处所定义的/main.jsp，如果认证失败则转向代码清单
3中②-3处所定义的/index.jsp?login_error=1。由于登录失败后也转向index.jsp页面，所以代码清单
4的①处专门对此进行了处理，当发现请求参数包含login_error时，打出一行提示登录失败的信息。

现在，我们已经了解了
authenticationProcessingFilter从何处获取需要进行认证的用户信息，并对认证成功和失败后的转向进行了定义。那么
authenticationProcessingFilter究竟如何对用户信息（用户名/密码）的合法性进行认证呢？

authenticationProcessingFilter其实只负责获取需要认证的用户信息并根据结果完成页面转向，它相当于一个客户受理的窗口，真正的用户身份认证工作则交由后台的AuthenticationManager完成。

下面，我们为authenticationProcessingFilter注入AuthenticationManager，后者将完成具体的身份认证工作：
代码清单 5 applicationContext-acegi-plugin.xml
认证管理器的配置

<beans>
…
<bean id="authenticationProcessingFilter"
class="org.acegisecurity.ui.webapp.AuthenticationProcessingFilter">
<property name="filterProcessesUrl" value="/j_acegi_security_check"/>
<property name="defaultTargetUrl" value="/main.jsp"/>
<property name="authenticationFailureUrl" value="/index.jsp?login_error=1"/>
①注入认证管理器
<property name="authenticationManager" ref="authenticationManager" />
</bean>
②认证管理器
<bean id="authenticationManager" class="org.acegisecurity.providers.ProviderManager">
<property name="providers">
<list>
②-1使用基于DAO的认证提供者提供认证服务
<ref local="daoAuthenticationProvider" />
</list>
</property>
</bean>
<bean id="daoAuthenticationProvider" ③基于DAO的认证提供者
class="org.acegisecurity.providers.dao.DaoAuthenticationProvider">
③-1根据用户名获取系统中真实UserDetails 对象的服务类
<property name="userDetailsService" ref="userDetailsService" />
</bean>
④ 该服务类根据缓存在内存中的用户信息列表获取userDetails对象
<bean id="userDetailsService" class="org.acegisecurity.userdetails.memory.InMemoryDaoImpl">
<property name="userMap"> ④-1用户信息
<value>
john=john,PRIV_COMMON,PRIV_1
tom=tom,PRIV_COMMON,PRIV_1,PRIV_2
peter=peter,disabled,PRIV_COMMON,PRIV_1
</value>
</property>
</bean>
</beans>

在①处，我们为authenticationProcessingFilter注入了一个AuthenticationManager Bean。AuthenticationManager有两个实现类：
l MockAuthenticationManager：这个实现类用于开发时的测试环境，它将所有待认证的用户标志为有效有户；
l ProviderManager：该实现类将用户身份认证的工作委托给多个提供者来完成。

这
里，我们使用ProviderManager来定义一个AuthenticationManager
Bean，如②所示。可以通过ProviderManager的providers属性配置多个认证提供者，认证提供者必须实现
org.acegisecurity.providers.AuthenticationProvider接口。身份认证的多样性通过
AuthenticationProvider接口实现类的多样性体现出来，Acegi针对不同的安全系统提供了10多个不同的认证提供者。这些不同的认证提供者在表 1中进行说明：

这里，我们使用DaoAuthenticationProvider，在②-1所示。它负责从数据库或其它保存用户信息的媒介中获取用户信息进行认证。

DaoAuthenticationProvider
首先从SecurityContextHolder的Authentication中得到待认证的用户名，并根据该用户名获取保存在数据库或其它媒介中代
表真正系统用户的UserDetails对象。紧接着比较Authentication和UserDetails的匹配关系（如看密码是否相等），如果两
者匹配，认证成功，并将UserDetails的权限信息将拷贝到Authentication中。如果不匹配，认证将失败。

DaoAuthenticationProvider通过UserDetailsService完成UserDetails的获取工作，根据存储用户信息媒介的不同，Acegi提供了两个UserDetailsService的实现类：

l InMemoryDaoImpl：该实现类负责从内存中获取用户的信息，它允许通过UserMap或Properties直接在Spring配置文件中定义系统用户信息。

l JdbcDaoImpl：该实现类从数据库中获取用户的信息。我们将在下一节讨论该实现类的使用方法。

在
这里，我们使用InMemoryDaoImpl获取UserDetails，如③-1所示并通过userMap属性定义系统用户信息，如④-1所示。
userMap属性的类型为UserMap，Acegi已经向Spring注册了对应的编辑器，所以我们可以通过格式化的字符串为UserMap类型的属
性提供配置值。在④-1处，我们提供了几行键值对的配置值，每一行代表一个用户及其对应的权限信息。下面我们通过图
2来了解代表一个用户的字符串的格式：

8 用户配置信息

我
们通过④-1定义了三个用户，john、tom和peter，它们对应的密码和用户名相同。其中john和tom是激活的用户，而peter用户处于非激
活状态。john和peter都拥有PRIV_COMMON,PRIV_1权限，而tom额外拥有PRIV_2的权限。

如果用户数比较多，在Spring中直接进行配置未免不太雅观，这时，你可以将用户信息转移到一个属性文件中，并通过userProperties进行加载：

<bean id="userDetailsService"

class="org.acegisecurity.userdetails.memory.InMemoryDaoImpl">

<property name="userProperties">

<bean class="org.springframework.beans.factory.config.PropertiesFactoryBean">

<property name="location" value="/WEB-INF/users.properties" />

</bean>

</property>

</bean>

users.properties文件内容的格式和刚才我们介绍的方式相同，既每一个用户对应一行格式化配置串。

通过以上分析后，我们可以理出参与用户身份认证所涉及到4个Bean，它们之间的关系可通过图 9来描述：

图 9 基于内存用户信息认证的主要Bean之间的关系

我们知道，大部分应用系统的用户信息并非一个小小的属性
文件可以应付的，它们一般保存在数据库中。InMemoryDaoImpl存在的更多意义在于方便程序测试——你可以不依赖外部数据库环境完成测试。在生
产环境下，我们应该使用JdbcDaoImpl这个UserDetailsService实现类从数据库中获取UserDetails。

基于数据库存储用户信息的认证

使用JdbcDaoImpl和InMemoryDaoImpl类似，它们的基本原理都是根据Authentication中待认证的用户名查询出代表真实系统用户的UserDetails对象。只不过，InMemoryDaoImpl通过查询驻留于内存中的格式化用户信息列表完成的，而JdbcDaoImpl则通过查询数据库达到目的。

在介绍JdbcDaoImpl的具体使用之前，我们先在数据库中创建用户信息表和用户权限表，并初始化一些测试的用户数据：

代码清单 6 创建用户及权限的SQL脚本

CREATE TABLE T_USER ( ①用户信息表 

USER_ID INTEGER NOT NULL AUTO_INCREMENT, 

USERNAME VARCHAR(30) NOT NULL, 

PASSWORD VARCHAR(30) DEFAULT NULL, 

STATUS TINYINT(1) NOT NULL DEFAULT '0', 

PRIMARY KEY (`USER_ID`), 

UNIQUE KEY `USERNAME` (`USERNAME`) 

); 

CREATE TABLE T_USER_PRIV (②用户权限表 

USER_ID INTEGER NOT NULL DEFAULT '0', 

PRIV_NAME VARCHAR(30) DEFAULT NULL, 

PRIMARY KEY (USER_ID, PRIV_NAME) 

); 

INSERT INTO T_USER (USER_ID, USERNAME, PASSWORD, STATUS) VALUES ③用户数据 

(1,'tom','tom',1), 

(2,'john','john',1); 

INSERT INTO T_USER_PRIV (USER_ID, PRIV_NAME) VALUES ④用户授权表 

(1,'PRIV_1'), 

(1,'PRIV_2'), 

(1,'PRIV_COMMON'), 

(2,'PRIV_1'), 

(2,'PRIV_COMMON'); 

COMMIT;

你可以简单地运行随书光盘的chapter17/schema/mysql/db.sql脚本文件完成用户安全相关信息表的创建工作。

下面，我们用JdbcDaoImpl替换InMemoryDaoImpl，从数据库中获取UserDetails对象，其代码如代码清单 7所示：

代码清单 7 applicationContext-acegi-plugin.xml

基于数据库存储的用信息获取

…
<bean id="daoAuthenticationProvider"
class="org.acegisecurity.providers.dao.DaoAuthenticationProvider">
①调整为从数据库获取UserDetails对象的服务类
<property name="userDetailsService" ref="userDetailsService" />
</bean>
<bean id="userDetailsService" class="org.acegisecurity.userdetails.jdbc.JdbcDaoImpl">②
<property name="dataSource" ref="dataSource" /> ②-1 数据源
<property name="usersByUsernameQuery"> ②-2 根据用户名查询用户的SQL语句
<value>
SELECT username,password, status FROM t_user WHERE username = ?
</value>
</property>
<property name="authoritiesByUsernameQuery"> ②-3 根据用户名查询用户权限记录的SQL语句
<value>
SELECT u.username,p.priv_name FROM t_user u,t_user_priv p
WHERE u.user_id =p.user_id AND u.username = ?
</value>
</property>
</bean>

这种替换的难度很小，仅需要配置一个JdbcDaoImpl Bean并将其作为daoAuthenticationProvider的userDetailsService的实现即可。

JdbcDaoImpl
其实是基于Spring
JDBC技术进行数据库访问的，它继承于org.springframework.jdbc.core.support.JdbcDaoSupport。
所以JdbcDaoImpl必不可少的一个属性是dataSource，它指定一个保存用户信息的数据源。

JdbcDaoImpl通过usersByUsernameQuery和authoritiesByUsernameQuery属性定义查询用户信息和用户权限的SQL语句。实际上，JdbcDaoImpl为以上两个属性提供了默认的SQL语句，分别是：

"SELECT username,password,enabled FROM users WHERE username = ?"

和

"SELECT username,authority FROM authorities WHERE username = ?"

一
般情况下，我们会使用自己的用户和权限表，所以你需要自定义以上两个属性。JdbcDaoImpl将Authentication中待认证用户名作为这两
个SQL语句的username参数值，并执行查询返回结果，然后根据列索引的方式从结果集中取得数据构造UserDetails对象，所以在构造SQL
语句时必须保持用户信息字段位于正确的列位置，字段名可以任意指定。

应该说，JdbcDaoImpl还不是非常实用的
UserDetailsService实现类，因为用户对象（UserDetails）除包含用户名/密码、是否激活、权限等信息外，还经常需要包含一些
诸如email、telephone等业务相关的信息。而JdbcDaoImpl通用类并不知道我们具体的业务需求，所以我们往往需要通过实现
UserDetailsService接口提供自己的实现类来完成这些工作。编写一个自己的UserDetailsService实现类不费什么力气，你
只要实现接口中的UserDetails loadUserByUsername(String
username)方法根据用户名获取UserDetails对象即可。在编写好自己的UserDetailsService后，在Spring配置并替
换①处的userDetailsService属性即可，限于篇幅，我们不再展开论述，读者可以试着自行完成。

小结
Acegi通过过滤器对请求实施拦截，当发现用户没有登录时，将强制用户进行系统登录，通过一定的接口规范，Acegi就可以获取操作者的用户身份，并进而获取用户的权限。在下一篇文章中，我们将接着介绍身份认证的高级话题。

Acegi学习小结

2008-11-18T06:21:00.001-08:00

Acegi学习小结

一、基本原理

Acegi认证授权主要基于两大技术，一是Filter机制，二是AOP的拦截机制。通过FilterSecurityInterceptor很
好地实现了对URI的保护，通过MethodSecurityInterceptor实现了对Service的方法的拦截保护，通过ACL
实现了对prototype类型的Object进行过滤和保护。

二、基本概念

HttpSessionContextIntegrationFilter 存储SecurityContext in HttpSession

ChannelProcessingFilter 重定向到另一种协议，如http到https

ConcurrentSessionFilter
因为不使用任何SecurityContextHolder的功能，但是需要更新SessionRegistry来表示当前的发送请求的
principal，通过在web.xml中注册Listener监听Session事件，并发布相关消息，然后由SessionRegistry获得消
息以判断当前用户的Session数量。

AuthenticationProcessingFilter 普通认证机制(大多数用这个)

CasProcessingFilter CAS认证机制

BasicProcessingFilter Http协议的Basic认证机制

HttpRequestIntegrationFilter Authentication 从容器的HttpServletRequest.getUserPrincipal()获得

JbossIntegrationFilter 与Jboss相关。

SecurityContextHolderAwareRequestFilter 与servlet容器结合使用。

RememberMeProcessingFilter 基于Cookies方式进行认证。

AnonymousProcessingFilter 匿名认证。

ExceptionTranslationFilter 捕获所有的Acegi Security 异常，这样要么返回一个HTTP错误响应或者加载一个对应的AuthenticationEntryPoint

AuthenticationEntryPoint 认证入口

三、Acegi认证授权流程

1、FilterToBeanProxy 负责代理请求给FilterChainProxy

2、FilterChainProxy 方便的将多个Filter串联起来，如上面基本概念中提到的各种Filter，当然如果对URI进行授权保护，也可以包含FilterSecurityInterceptor。注意各Filter的顺序。

3、AbstractSecurityInterceptor 调度中心。负责调用各模块完成相应功能。

   FilterSecurityInterceptor 对URI进行拦截保护

AspectJSecurityInterceptor 对方法进行拦截保护

MethodSecurityInterceptor 对方法进行拦截保护

4、AuthenticationManager 用户认证

-> AuthenticationProvider 实际进行用户认证的地方(多个)。

     -> UserDetailsService 返回带有GrantedAuthority的UserDetail或者抛出异常。

5、AccessDecisionManager(UnanimousBased/AffirmativeBased/ConsensusBased) 授权

-> AccessDecisionVoter(RoleVoter/BaseAclEntryVoter) 实际投票的Voter(多个).

6、RunAsManager 变更GrantedAuthority

7、AfterInvocationManager 变更返回的对象

   -> BaseInvocationProvider 实际完成返回对象变更的地方(多个)。

四、Acegi实例

http://www.javaeye.com/topic/43341

声明：JavaEye文章版权属于作者，受法律保护。没有作者书面许可不得转载。

javascript 处理 JSON

2008-11-18T05:54:00.003-08:00

javascript 处理 JSON

用 javascript 处理 JSON

关键字: json javascript

    因为JSON 是 javascript 的一个子集，所以，在javascript 中使用JSON是非常简单的。

js 代码

var myJSONObject = {"bindings": [
{"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"},
{"ircEvent": "PRIVMSG", "method": "deleteURI", "regex": "^delete.*"},
{"ircEvent": "PRIVMSG", "method": "randomURI", "regex": "^random.*"}
]
};

在上面的例子中，我们创建了只包含一个成员 "bindings" 的一个对象，bindings 则包含了一个由3个对象组成的数组。这3个对象都包含3个成员："ircEvent"， "method"，"regex"。

在javascript 中，成员可以通过“点号”来获取。

比如：

js 代码

myJSONObject.bindings[0].method

通过eval() 函数可以将JSON字符串转化为对象。

js 代码

var myObject = eval('(' + myJSONtext + ')');

eval 函数非常快，但是它可以编译任何 javascirpt 代码，这样的话就可能产生安全的问题。eval 的使用是基于传入的代码参数是可靠的假设的，有一些情况下，可能客户端是不可信任的。

如果基于安全的考虑的话，最好是使用一个 JSON 解析器。一个 JSON 解析器将只接受 JSON 文本。所以是更安全的。

js 代码

var myObject = JSON.parse(myJSONtext, filter);

可选的 filter 参数将遍历每一个value key 值对，并进行相关的处理。如：

js 代码

myData = JSON.parse(text, function (key, value) {
1. return key.indexOf('date') >= 0 ? new Date(value) : value; });

stringifier 函数的作用跟 parse 相反，用来将一个js对象转换为 JSON 文本。

js 代码

var myJSONText = JSON.stringifier(myObject);

这里是一个开源的 JSON parser and JSON stringifier

json2.rar (3.2 KB)
描述: 一个开源的 JSON parser and JSON stringifier
下载次数: 272

11:07
浏览 (1973)
评论 (2)
分类: AJAX
进入论坛
收藏
相关推荐

tonyhelp
2008-09-17
引用

我也翻译过这篇文章

我也用过 DOJO ,现在改用 jQuery了

wangsong76
2008-08-22
引用

我也翻译过这篇文章

我也用过 DOJO ,现在改用 jQuery了。

在异步应用程序中发送和接收信息时，可以选择以纯文本和 XML 作为数据格式。掌握 Ajax 的这一期讨论另一种有用的数据格式 JavaScript Object Notation（JSON），以及如何使用它更轻松地在应用程序中移动数据和对象。

　　如果您阅读了本系列前面的文章，那么应已对数据格式有了相当的认识。前面的文章解释了在许多异步应用程序中如何恰当地使用纯文本和简单的名称/值对。可以将数据组合成下面这样的形式：

firstName=Brett&lastName=McLaughlin&email=brett@newInstance.com

　　这样就行了，不需要再做什么了。实际上，Web 老手会意识到通过 GET 请求发送的信息就是采用这种格式。

　　然后，本系列讨论了 XML。显然，XML 得到了相当多的关注（正面和负面的评价都有），已经在 Ajax 应用程序中广泛使用。关于如何使用 XML 数据格式，可以回顾本系列前面的文章：

<request>
<firstName>Brett</firstName>
<lastName>McLaughlin</lastName>
<email>brett@newInstance.com</email>
</request>

　　这里的数据与前面看到的相同，但是这一次采用 XML 格式。这没什么了不起的；这只是另一种数据格式，使我们能够使用 XML 而不是纯文本和名称/值对。

　　本文讨论另一种数据格式，JavaScript Object Notation（JSON）。JSON 看起来既熟悉又陌生。它提供了另一种选择，选择范围更大总是好事情。

　　选择的意义

　
　在深入研究 JSON 格式的细节之前，您应该了解为什么要用两篇文章讨论另一种数据格式（是的，本系列中的下一篇文章也讨论
JSON），尤其在已经了解了如何使用 XML 和纯文本的名称/值对的情况下。其实，原因很简单：解决任何问题的选择越多，找到问题的最佳
解决方案的可能性就越大，这比只能使用一个解决方案要好得多。

回顾名称/值对和 XML

　　本系列已经用了大量篇幅讨论适合使用名称/值对和 XML 的场合。总是应该首先考虑使用名称/值对。对于大多数异步应用程序中的问题，使用名称/值对几乎总是最简单的解决方案，而且它只需要非常基本的 JavaScript 知识。

　
　实际上，除非有某种限制迫使您转向 XML，否则用不着考虑使用别的数据格式。显然，如果要向需要 XML
格式的输入的服务器端程序发送数据，那么希望使用 XML 作为数据格式。但是，在大多数情况下，对于需要向应用程序发送多段信息的服务器，XML
是更好的选择；换句话说，XML 通常更适合用来向 Ajax 应用程序做出响应，而不是从 Ajax 应用程序发出请求。

添加 JSON

　
　在使用名称/值对或 XML 时，实际上是使用 JavaScript
从应用程序中取得数据并将数据转换成另一种数据格式。在这些情况下，JavaScript 在很大程度上作为一种数据操纵语言，用来移动和操纵来自
Web 表单的数据，并将数据转换为一种适合发送给服务器端程序的格式。

　　但是，有时候 JavaScript
不仅仅作为格式化语言使用。在这些情况下，实际上使用 JavaScript 语言中的对象来表示数据，而不仅是将来自 Web
表单的数据放进请求中。在这些情况下，从 JavaScript 对象中提取数据，然后再将数据放进名称/值对或 XML，就有点儿多此一举
了。这时就合适使用 JSON：JSON 允许轻松地将 JavaScript 对象转换成可以随请求发送的数据（同步或异步都可以）。

　　JSON 并不是某种魔弹；但是，它对于某些非常特殊的情况是很好的选择。不要认为您不会遇到这些情况。阅读本文和下一篇文章来了解 JSON，这样，遇到这类问题时您就知道该怎么办了。

JSON 基础

　
　简单地说，JSON 可以将 JavaScript
对象中表示的一组数据转换为字符串，然后就可以在函数之间轻松地传递这个字符串，或者在异步应用程序中将字符串从 Web
客户机传递给服务器端程序。这个字符串看起来有点儿古怪（稍后会看到几个示例），但是 JavaScript 很容易解释它，而且 JSON
可以表示比名称/值对更复杂的结构。例如，可以表示数组和复杂的对象，而不仅仅是键和值的简单列表。

简单 JSON 示例

　　按照最简单的形式，可以用下面这样的 JSON 表示名称/值对：

{ "firstName": "Brett" }

　　这个示例非常基本，而且实际上比等效的纯文本名称/值对占用更多的空间：

firstName=Brett

　　但是，当将多个名称/值对串在一起时，JSON 就会体现出它的价值了。首先，可以创建包含多个名称/值对的记录，比如：

{ "firstName": "Brett", "lastName":"McLaughlin", "email": "brett@newInstance.com" }

　　从语法方面来看，这与名称/值对相比并没有很大的优势，但是在这种情况下 JSON 更容易使用，而且可读性更好。例如，它明确地表示以上三个值都是同一记录的一部分；花括号使这些值有了某种联系。

值的数组

　
　当需要表示一组值时，JSON 不但能够提高可读性，而且可以减少复杂性。例如，假设您希望表示一个人名列表。在 XML
中，需要许多开始标记和结束标记；如果使用典型的名称/值对（就像在本系列前面文章中看到的那种名称/值对），那么必须建立一种专有的数据格式，或者将键
名称修改为 person1-firstName 这样的形式。

　　如果使用 JSON，就只需将多个带花括号的记录分组在一起：

{ "people": [
{ "firstName": "Brett", "lastName":"McLaughlin", "email": "brett@newInstance.com" },
{ "firstName": "Jason", "lastName":"Hunter", "email": "jason@servlets.com" },
{ "firstName": "Elliotte", "lastName":"Harold", "email": "elharo@macfaq.com" }
]}

　　这不难理解。在这个示例中，只有一个名为 people 的变量，值是包含三个条目的数组，每个条目是一个人的记录，其中包含名、姓和电子邮件地址。上面的示例演示如何用括号将记录组合成一个值。当然，可以使用相同的语法表示多个值（每个值包含多个记录）：

{ "programmers": [
{ "firstName": "Brett", "lastName":"McLaughlin", "email": "brett@newInstance.com" },
{ "firstName": "Jason", "lastName":"Hunter", "email": "jason@servlets.com" },
{ "firstName": "Elliotte", "lastName":"Harold", "email": "elharo@macfaq.com" }
],
"authors": [
{ "firstName": "Isaac", "lastName": "Asimov", "genre": "science fiction" },
{ "firstName": "Tad", "lastName": "Williams", "genre": "fantasy" },
{ "firstName": "Frank", "lastName": "Peretti", "genre": "christian fiction" }
],
"musicians": [
{ "firstName": "Eric", "lastName": "Clapton", "instrument": "guitar" },
{ "firstName": "Sergei", "lastName": "Rachmaninoff", "instrument": "piano" }
]
}

　　这里最值得注意的是，能够表示多个值，每个值进而包含多个值。但是还应该注意，在不同的主条目（programmers、authors
和 musicians）之间，记录中实际的名称/值对可以不一样。JSON 是完全动态的，允许在 JSON 结构的中间改变表示数据的方式。

　　在处理 JSON 格式的数据时，没有需要遵守的预定义的约束。所以，在同样的数据结构中，可以改变表示数据的方式，甚至可以以不同方式表示同一事物。

在 JavaScript 中使用 JSON

　　掌握了 JSON 格式之后，在 JavaScript 中使用它就很简单了。JSON 是 JavaScript 原生格式，这意味着在 JavaScript 中处理 JSON 数据不需要任何特殊的 API 或工具包。

将 JSON 数据赋值给变量

　　例如，可以创建一个新的 JavaScript 变量，然后将 JSON 格式的数据字符串直接赋值给它：

var people =
{ "programmers": [
{ "firstName": "Brett", "lastName":"McLaughlin", "email": "brett@newInstance.com" },
{ "firstName": "Jason", "lastName":"Hunter", "email": "jason@servlets.com" },
{ "firstName": "Elliotte", "lastName":"Harold", "email": "elharo@macfaq.com" }
],
"authors": [
{ "firstName": "Isaac", "lastName": "Asimov", "genre": "science fiction" },
{ "firstName": "Tad", "lastName": "Williams", "genre": "fantasy" },
{ "firstName": "Frank", "lastName": "Peretti", "genre": "christian fiction" }
],
"musicians": [
{ "firstName": "Eric", "lastName": "Clapton", "instrument": "guitar" },
{ "firstName": "Sergei", "lastName": "Rachmaninoff", "instrument": "piano" }
]
}

　　这非常简单；现在 people 包含前面看到的 JSON 格式的数据。但是，这还不够，因为访问数据的方式似乎还不明显。

访问数据

　
　尽管看起来不明显，但是上面的长字符串实际上只是一个数组；将这个数组放进 JavaScript
变量之后，就可以很轻松地访问它。实际上，只需用点号表示法来表示数组元素。所以，要想访问 programmers 列表的第一个条目的姓氏，只需在
JavaScript 中使用下面这样的代码：

people.programmers[0].lastName;

　　注意，数组索引是从零开始的。所以，这行代码首先访问 people 变量中的数据；然后移动到称为 programmers 的条目，再移动到第一个记录（[0]）；最后，访问 lastName 键的值。结果是字符串值 “McLaughlin”。

　　下面是使用同一变量的几个示例。

people.authors[1].genre // Value is "fantasy"

people.musicians[3].lastName // Undefined. This refers to the fourth entry,
and there isn't one

people.programmers.[2].firstName // Value is "Elliotte"

　　利用这样的语法，可以处理任何 JSON 格式的数据，而不需要使用任何额外的 JavaScript 工具包或 API。

修改 JSON 数据

　　正如可以用点号和括号访问数据，也可以按照同样的方式轻松地修改数据：
people.musicians[1].lastName = "Rachmaninov";
　　在将字符串转换为 JavaScript 对象之后，就可以像这样修改变量中的数据。

转换回字符串

　　当然，如果不能轻松地将对象转换回本文提到的文本格式，那么所有数据修改都没有太大的价值。在 JavaScript 中这种转换也很简单：

String newJSONtext = people.toJSONString();

　　这样就行了！现在就获得了一个可以在任何地方使用的文本字符串，例如，可以将它用作 Ajax 应用程序中的请求字符串。

　　更重要的是，可以将任何 JavaScript 对象转换为 JSON 文本。并非只能处理原来用 JSON 字符串赋值的变量。为了对名为 myObject 的对象进行转换，只需执行相同形式的命令：

String myObjectInJSON = myObject.toJSONString();

　　这就是 JSON 与本系列讨论的其他数据格式之间最大的差异。如果使用
JSON，只需调用一个简单的函数，就可以获得经过格式化的数据，可以直接使用了。对于其他数据格式，需要在原始数据和格式化数据之间进行转换。即使使用
Document Object Model 这样的 API（提供了将自己的数据结构转换为文本的函数），也需要学习这个 API 并使用 API
的对象，而不是使用原生的 JavaScript 对象和语法。

　　最终结论是，如果要处理大量 JavaScript 对象，那么 JSON 几乎肯定是一个好选择，这样就可以轻松地将数据转换为可以在请求中发送给服务器端程序的格式。

针对JSON的基于java和js多种操作与格式转换方法

2008-11-18T05:54:00.001-08:00

针对JSON的基于java和js多种操作与格式转换方法

转

org.json包

http://www.json.org/java/index.html

1.      JSONObject，用一个HashMap来保存一个JSON对象的所有属性。

2.
JSONArray用ArrayList来保存数据。JSON来自javascript，javascript
中Array也是Object，不知这里是如何保存这种关系的。

3.      一些跟字符串有关的类，以及异常类。

4.      一些工具类，比如xml和json转换的类，将http头和cookies转换为json的类，

基于org.json包的JSON-LIB：bean，map，collection，java array，xml与json间的转换。

http://json-lib.sourceforge.net/

http://json-lib.sourceforge.net/usage.html

Stringtree JSON:JSON与java对象间的转换

http://www.stringtree.org/stringtree-json.html

三个关键类：

JSONReader.java

JSONWriter.java

JSONValidator.java

JSONValidator用来检查JSON的有效性。

JSONReader将一个正确形式的JSON字符串转换为一个java对象。

JSONWriter将一个java对象转换为一个JSON字符串。

JSONT：基于js和自定义规则，转换JSON为任意其他格式

http://goessner.net/articles/jsont/

Web 设计:实现干净代码的12条定律

2008-11-16T21:20:00.001-08:00

Web 设计:实现干净代码的12条定律

Web 设计:实现干净代码的12条定律_cnBeta 视点·观察_cnBeta.COM

新闻来源:Smashing Magazine

漂亮的代码是漂亮网站的基础，优秀的 CSS 只存在与同样优秀的 HTML 之上，干净的，语义的 HTML 代码让一个网站更健壮。本文讲述了12个实现干净 Web 设计代码的定律，适合于任何从事 Web 设计的人。

1. Strict DOCTYPE

要做就做对的。不管是 HTML 4.01 还是 XHTML 1.0，它们都提供 Strict 模式，使用 Strict 模式可以保证我们的代码不隐藏任何错误。

参考资料:

W3C: Recommended DTDs to use in your Web document

Fix Your Site With the Right DOCTYPE!

No more Transitional DOCTYPEs, please

2. 字符集声明，特殊字符进行编码处理

字符集声明应当放在 <hea> 部分的最前面，以便让浏览器知道如何显示网页中的所有内容，包括标题。另外，一些特殊字符，如 & 最好用 & 代替，这是一种最安全的方法。

参考资料:

Wikipedia: UTF-8

A tutorial on character code issues

The Extended ASCII table

3. 恰当的锁进

缩进不会影响网页的渲染，但会明显改善阅读源代码时的体验。缩进没有特定的规则，但始终保持一致是个好习惯。

参考资料:

Clean up your Web pages with HTML TIDY

4. 将 CSS 和 JavaScript 放在外部文件中

将 CSS 和 JavaScript 放在外部文件中引用，不仅减低单个网页的尺寸，而且意味着其它网页也可以共用这些代码，另外，浏览器的缓存机制可以很好地降低对相同代码的重复下载。

5. 正确地嵌套 Tag 标签

如下图，第一行代码中，<h1>标签嵌套在 <a>标签中，尽管多数浏览器会正确渲染，但这不是好的习惯，标签是 block 对象，而是 inline 对象，inline 对象不应该容纳 block 对象。

6. 消除不必要的 <div>

<div> 常被滥用（尤其在我们现在所处的 DIV+CSS 神话中 - 译者），人们希望把任何东西都放在 <div> 中以便为它们分配 CSS 式样，这种滥用会导致的臃肿。

参考资料:

Divitis: what it is, and how to cure it.

7. 使用更好的命名规则

如下图，Cat 的 CSS 类被命名为 red italic，暗示着 Cat 使用红色斜体，如果你想将 Cat 改成兰色的粗体呢？

8. 尽量使用 CSS 控制文字的排版

如下图所示，不要直接使用大写，用 CSS 对这些文字排版方面的格式进行控制，这样会更灵活。

9. 为 <body> 分配独立的 class/id

为 body Tag 分配一个独立的 class/id，可以很好地定位页面中任何对象，因为页面中所有对象都位于 body 中。

参考资料:

ID Your Body For Greater CSS Control and Specificity

Case study: Re-using styles with a body class

10. 验证

无需多言，你应当尽可能对网页的代码进行验证，尽管有些代码错误浏览器能自动更正，但有些错误是会带来不好的后果的，尤其当你位于 Strict 模式下。即使什么都不为，看到那个绿色的 W3C 验证标志至少可以让自己舒服一些。

W3C 验证是否通过并不一定要什么拘泥，Web 设计中存在更多的考量，只拘泥 W3C 验证结果，可能影响一些更重要的因素，比如，IE6 在
W3C 标准方面存在不少 BUG，如果你为了100%通过 W3C 验证而宣布自己的网站不支持 IE6，至少在国内会得不偿失的 - 译者

参考资料:

The W3C Markup Validation Service

XHTML-CSS Validator

Free Site Validator (checks entire site, not just one page)

11. 合理的结构次序

将网页结构保持一个合乎逻辑的次序。

12. 尽你所能

如果你从零开始写，保持以上的原则当然要容易的多，如果要修改旧的代码，将会很痛苦，一些 CMS 系统拙劣的编码会让你陷入泥沼，或者你的网站规模宏大要改动的东西太多，不管怎样，始终保持良好的习惯非常重要。

web

中国房地产的实质

2008-11-14T21:23:00.000-08:00

猪通过勤劳致富有5元钱存在老鼠开的钱庄里。猪打算拿这5元钱建一个小窝，大盖要花2元买地，花3元搭窝。

王八是搞工程的，他想在猪身上挣更多的钱，于是找来当投资顾问的狐狸想办法，狐狸说：这好办。于是找来管地盘的狼，开钱庄的老鼠一起来商议，结果王八从老鼠那里借来200元，用100元卖了狼的地，花了3元把猪窝盖好，花了50元给了狐狸咨询服务费，猪没有地，只好求王八把窝卖给它，王八要价500元，老猪说只有5元买不起，这时候狐狸说服猪去向老鼠借钱，老鼠答应借500给猪，前提是要他连本带利还600元，可以分10年还清，并且产权证拿来抵押。结果成交。猪到最后花了600元买来了猪窝，比他原来的计划高了120倍，猪努力了十年去挣钱还贷。在这场交易里面，狼，老鼠，狐狸还有王八都挣了钱。

以后他们就如法炮制。更多的猪去贷款买房子了，这时候，当商人的驴看到有机可乘，到老鼠那里贷了好多好多的款，把王八盖的房子都买下来，然后以更高的价格卖给了猪。

猪的还贷期就越来越长，吃的越来越差，小猪崽子也不敢生了。由于猪的数目越来越少，狼觉得这样下去自己没有猪肉吃了，非饿死不可，于是开始调控，不让老鼠再借钱了。但是王八还没有停止盖房，把自己挣的钱和贷的钱全投入生产了。驴手上的猪窝囤积的很多，卖不动了被套牢了。结果，老鼠，王八，还有驴都挣了好多的猪窝。

钱到最后集中到狼手上。如今，谁都等着狼把钱拿出来救命。

聪明的你，如果你是狼，你会拿钱救哪个？

SSH整合时Session关闭问题解决之道(原创)

2008-11-14T21:19:00.001-08:00

SSH整合时Session关闭问题解决之道(原创)

hibernate的策略是在检索时并不返回完整的类字段，以保证性能，当对具体对象进行实例化的时候，重新连接数据库来填充对象。

这在应用初期常出现的问题就是总碰到session is closed的错误提示，其实很简单，hibernate对数据库的连接都是由它的session统一维持的，当一段程序完成后，session已经关闭，这时再进行实例化，就会出现以上错误，因此，需要重新建立一个seesion来完成操作。（啥，把lazy load设置为false不就得了？那还用hibernate干啥？十几个多表关联下来，自己累不死，数据库也累死了）

对于一直使用spring集成hibernate的我，这些事情完全不需要自己来做。

首先我从不自己去操作hibernate，全都通过spring的hibernateTemplate来完成。

其次，spring的强项就是简易AOP，自然不会坐视俺这样的it小工为此操劳。

在spring的orm中，为hibernate提供了三个类来处理lazy load问题：

HibernateInterceptor：处理业务逻辑层的问题（普通应用程序），使用ProxyFactoryBean来配置实际业务中的bean，将HibernateInterceptor注入其interceptorNames属性中，则自己的程序就不必操心session的问题了，需要时，spring会帮你建立一个，不需要时，spring会将其关闭。

OpenSessionInViewInterceptor：在springMVC中使用，SimpleUrlHandlerMapping中注入interceptors属性内，那么在视图（jsp等）里访问实体对象也ok了。

OpenSessionInViewFilter：不用springMVC的就使这个吧，在web.xml中配置一个过滤器，其他的mvc框架也就不受影响了。

could not initialize proxy - the owning Session wa

其实这个异常写的非常之清楚，就是会话关闭，无法对Hibernate实体进行操作。造成这样的情况有很多，什么书写错误啊，逻辑错误啊。
　　
　　但就此说一下关于lazy机制：
　　
　　延迟初始化错误是运用Hibernate开发项目时最常见的错误。如果对一个类或者集合配置了延迟检索策略，那么必须当代理类实例或代理集合处于持久化状态（即处于Session范围内）时，才能初始化它。如果在游离状态时才初始化它，就会产生延迟初始化错误。
　　
　　下面把Customer.hbm.xml文件的<class>元素的lazy属性设为true，表示使用延迟检索策略：
　　
　　<class name="mypack.Customer" table="CUSTOMERS" lazy="true">
　　
　　当执行Session的load()方法时，Hibernate不会立即执行查询CUSTOMERS表的select语句，仅仅返回Customer类的代理类的实例，这个代理类具由以下特征：
　　
　　（1）由Hibernate在运行时动态生成，它扩展了Customer类，因此它继承了Customer类的所有属性和方法，但它的实现对于应用程序是透明的。
　　（2）当Hibernate创建Customer代理类实例时，仅仅初始化了它的OID属性，其他属性都为null，因此这个代理类实例占用的内存很少。
　　（3）当应用程序第一次访问Customer代理类实例时（例如调用customer.getXXX()或customer.setXXX()方法）， Hibernate会初始化代理类实例，在初始化过程中执行select语句，真正从数据库中加载Customer对象的所有数据。但有个例外，那就是当应用程序访问Customer代理类实例的getId()方法时，Hibernate不会初始化代理类实例，因为在创建代理类实例时OID就存在了，不必到数据库中去查询。
　　
　　提示：Hibernate采用CGLIB工具来生成持久化类的代理类。CGLIB是一个功能强大的Java字节码生成工具，它能够在程序运行时动态生成扩展 Java类或者实现Java接口的代理类。关于CGLIB的更多知识，请参考：http://cglib.sourceforge.net/。
　　
　　以下代码先通过Session的load()方法加载Customer对象，然后访问它的name属性：
　　
　　tx = session.beginTransaction();
　　Customer customer=(Customer)session.load(Customer.class,new Long(1));
　　customer.getName();
　　tx.commit();
　　
　　在运行session.load()方法时Hibernate不执行任何select语句，仅仅返回Customer类的代理类的实例，它的OID为1，这是由load()方法的第二个参数指定的。当应用程序调用customer.getName()方法时，Hibernate会初始化Customer代理类实例，从数据库中加载Customer对象的数据，执行以下select语句：
　　
　　select * from CUSTOMERS where ID=1;
　　select * from ORDERS where CUSTOMER_ID=1;
　　
　　当<class>元素的lazy属性为true，会影响Session的load()方法的各种运行时行为，下面举例说明。
　　
　　1．如果加载的Customer对象在数据库中不存在，Session的load()方法不会抛出异常，只有当运行customer.getName()方法时才会抛出以下异常：
　　
　　ERROR LazyInitializer:63 - Exception initializing proxy
　　net.sf.hibernate.ObjectNotFoundException: No row with the given identifier exists: 1, of class:
　　mypack.Customer
　　
　　2．如果在整个Session范围内，应用程序没有访问过Customer对象，那么Customer代理类的实例一直不会被初始化，Hibernate不会执行任何select语句。以下代码试图在关闭Session后访问Customer游离对象：
　　
　　tx = session.beginTransaction();
　　Customer customer=(Customer)session.load(Customer.class,new Long(1));
　　tx.commit();
　　session.close();
　　customer.getName();
　　
　　由于引用变量customer引用的Customer代理类的实例在Session范围内始终没有被初始化，因此在执行customer.getName()方法时，Hibernate会抛出以下异常：
　　
　　ERROR LazyInitializer:63 - Exception initializing proxy
　　net.sf.hibernate.HibernateException: Could not initialize proxy - the owning Session was closed
　　
　　由此可见，Customer代理类的实例只有在当前Session范围内才能被初始化。
　　
　　3．net.sf.hibernate.Hibernate类的initialize()静态方法用于在Session范围内显式初始化代理类实例，isInitialized()方法用于判断代理类实例是否已经被初始化。例如：
　　
　　tx = session.beginTransaction();
　　Customer customer=(Customer)session.load(Customer.class,new Long(1));
　　if(!Hibernate.isInitialized(customer))
　　Hibernate.initialize(customer);
　　tx.commit();
　　session.close();
　　customer.getName();
　　
　　以上代码在Session范围内通过Hibernate类的initialize()方法显式初始化了Customer代理类实例，因此当Session关闭后，可以正常访问Customer游离对象。
　　
　　4．当应用程序访问代理类实例的getId()方法时，不会触发Hibernate初始化代理类实例的行为，例如：
　　
　　tx = session.beginTransaction();
　　Customer customer=(Customer)session.load(Customer.class,new Long(1));
　　customer.getId();
　　tx.commit();
　　session.close();
　　customer.getName();
　　
　　当应用程序访问customer.getId()方法时，该方法直接返回Customer代理类实例的OID值，无需查询数据库。由于引用变量 customer始终引用的是没有被初始化的Customer代理类实例，因此当Session关闭后再执行customer.getName()方法， Hibernate会抛出以下异常：
　　
　　ERROR LazyInitializer:63 - Exception initializing proxy
　　net.sf.hibernate.HibernateException: Could not initialize proxy - the owning Session was closed
　　
　　
　　解决方法：
　　
　　由于hibernate采用了lazy=true,这样当你用hibernate查询时,返回实际为利用cglib增强的代理类,但其并没有实际填充;当你在前端,利用它来取值(getXXX)时,这时Hibernate才会到数据库执行查询,并填充对象,但此时如果和这个代理类相关的session已关闭掉,就会产生种错误.
　　在做一对多时，有时会出现"could not initialize proxy - clothe owning Session was sed,这个好像是hibernate的缓存问题.问题解决:需要在<many-to-one>里设置lazy="false". 但有可能会引发另一个异常叫
　　
　　failed to lazily initialize a collection of role: XXXXXXXX, no session or session was closed
　　
　　此异常解决方案请察看本人博客（http://hi.baidu.com/kekemao1）的Hibernate异常中的《failed to lazily initialize a collection of role异常》
　　
　　?
　　解决方法:在web.xml中加入
　　<filter>
　　    <filter-name>hibernateFilter</filter-name>
　　    <filter-class>
　　     org.springframework.orm.hibernate3.support.OpenSessionInViewFilter
　　    </filter-class>
　　</filter
　　<filter-mapping>
　　    <filter-name>hibernateFilter</filter-name>
　　    <url-pattern>*.do</url-pattern>
　　</filter-mapping>
　　就可以了;
　　
　　参考了:
　　Hibernate与延迟加载：
　　
　　Hibernate对象关系映射提供延迟的与非延迟的对象初始化。非延迟加载在读取一个对象的时候会将与这个对象所有相关的其他对象一起读取出来。这有时会导致成百的（如果不是成千的话）select语句在读取对象的时候执行。这个问题有时出现在使用双向关系的时候，经常会导致整个数据库都在初始化的阶段被读出来了。当然，你可以不厌其烦地检查每一个对象与其他对象的关系，并把那些最昂贵的删除，但是到最后，我们可能会因此失去了本想在ORM工具中获得的便利。
　　
　　
　　一个明显的解决方法是使用Hibernate提供的延迟加载机制。这种初始化策略只在一个对象调用它的一对多或多对多关系时才将关系对象读取出来。这个过程对开发者来说是透明的，而且只进行了很少的数据库操作请求，因此会得到比较明显的性能提升。这项技术的一个缺陷是延迟加载技术要求一个Hibernate会话要在对象使用的时候一直开着。这会成为通过使用DAO模式将持久层抽象出来时的一个主要问题。为了将持久化机制完全地抽象出来，所有的数据库逻辑，包括打开或关闭会话，都不能在应用层出现。最常见的是，一些实现了简单接口的DAO实现类将数据库逻辑完全封装起来了。一种快速但是笨拙的解决方法是放弃DAO模式，将数据库连接逻辑加到应用层中来。这可能对一些小的应用程序有效，但是在大的系统中，这是一个严重的设计缺陷，妨碍了系统的可扩展性。
　　
　　在Web层进行延迟加载
　　
　　幸运的是，Spring框架为Hibernate延迟加载与DAO模式的整合提供了一种方便的解决方法。对那些不熟悉Spring与Hibernate集成使用的人，我不会在这里讨论过多的细节，但是我建议你去了解Hibernate与Spring集成的数据访问。以一个Web应用为例，Spring提供了OpenSessionInViewFilter和OpenSessionInViewInterceptor。我们可以随意选择一个类来实现相同的功能。两种方法唯一的不同就在于interceptor在Spring容器中运行并被配置在web应用的上下文中，而Filter在Spring之前运行并被配置在web.xml中。不管用哪个，他们都在请求将当前会话与当前（数据库）线程绑定时打开Hibernate会话。一旦已绑定到线程，这个打开了的Hibernate会话可以在DAO实现类中透明地使用。这个会话会为延迟加载数据库中值对象的视图保持打开状态。一旦这个逻辑视图完成了，Hibernate会话会在Filter的doFilter方法或者Interceptor的postHandle方法中被关闭。下面是每个组件的配置示例：
　　
　　
　　
　　Interceptor的配置:
　　
　　
　　<beans>
　　<bean id="urlMapping"
　　class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
　　<property name="interceptors">
　　<list>
　　<ref bean="openSessionInViewInterceptor"/>
　　</list>
　　</property>
　　<property name="mappings">
　　
　　</bean>
　　
　　<bean name="openSessionInViewInterceptor"
　　class="org.springframework.orm.hibernate.support.OpenSessionInViewInterceptor">
　　<property name="sessionFactory"><ref bean="sessionFactory"/></property>
　　</bean>
　　</beans>
　　
　　Filter的配置
　　
　　
　　<web-app>
　　
　　<filter>
　　<filter-name>hibernateFilter</filter-name>
　　<filter-class>
　　org.springframework.orm.hibernate.support.OpenSessionInViewFilter
　　</filter-class>
　　</filter>
　　
　　<filter-mapping>
　　<filter-name>hibernateFilter</filter-name>
　　<url-pattern>*. spring </url-pattern>
　　</filter-mapping>
　　
　　</web-app>
　　
　　
　　实现Hibernate的Dao接口来使用打开的会话是很容易的。事实上，如果你已经使用了Spring框架来实现你的Hibernate Dao,很可能你不需要改变任何东西。方便的HibernateTemplate公用组件使访问数据库变成小菜一碟，而DAO接口只有通过这个组件才可以访问到数据库。下面是一个示例的DAO：
　　
　　
　　public class HibernateProductDAO extends HibernateDaoSupport implements ProductDAO {
　　
　　public Product getProduct(Integer productId) {
　　return (Product)getHibernateTemplate().load(Product.class, productId);
　　}
　　
　　public Integer saveProduct(Product product) {
　　return (Integer) getHibernateTemplate().save(product);
　　}
　　
　　public void updateProduct(Product product) {
　　getHibernateTemplate().update(product);
　　}
　　}
　　
　　
　　在业务逻辑层中使用延迟加载
　　
　　即使在视图外面，Spring框架也通过使用AOP 拦截器 HibernateInterceptor来使得延迟加载变得很容易实现。这个Hibernate 拦截器透明地将调用配置在Spring应用程序上下文中的业务对象中方法的请求拦截下来，在调用方法之前打开一个Hibernate会话，然后在方法执行完之后将会话关闭。让我们来看一个简单的例子，假设我们有一个接口BussinessObject：
　　
　　
　　public     interface    BusinessObject     {
　　public     void    doSomethingThatInvolvesDaos();
　　}
　　类BusinessObjectImpl实现了BusinessObject接口:
　　
　　public     class    BusinessObjectImpl    implements    BusinessObject     {
　　public     void    doSomethingThatInvolvesDaos()     {
　　//    lots of logic that calls
　　//    DAO classes Which access
　　//    data objects lazily
　　}
　　}
　　
　　
　　
　　通过在Spring应用程序上下文中的一些配置，我们可以让将调用BusinessObject的方法拦截下来，再令它的方法支持延迟加载。看看下面的一个程序片段：
　　
　　
　　
　　<beans>
　　<bean id="hibernateInterceptor" class="org.springframework.orm.hibernate.HibernateInterceptor">
　　<property name="sessionFactory">
　　<ref bean="sessionFactory"/>
　　</property>
　　</bean>
　　<bean id="businessObjectTarget" class="com.acompany.BusinessObjectImpl">
　　<property name="someDAO"><ref bean="someDAO"/></property>
　　</bean>
　　<bean id="businessObject" class="org.springframework.aop.framework.ProxyFactoryBean">
　　<property name="target"><ref bean="businessObjectTarget"/></property>
　　<property name="proxyInterfaces">
　　<value>com.acompany.BusinessObject</value>
　　</property>
　　<property name="interceptorNames">
　　<list>
　　<value>hibernateInterceptor</value>
　　</list>
　　</property>
　　</bean>
　　</beans>
　　
　　当businessObject被调用的时候，HibernateInterceptor打开一个Hibernate会话，并将调用请求传递给BusinessObjectImpl对象。当BusinessObjectImpl执行完成后，HibernateInterceptor透明地关闭了会话。应用层的代码不用了解任何持久层逻辑，还是实现了延迟加载。
　　
　　
　　在单元测试中测试延迟加载
　　
　　最后，我们需要用J-Unit来测试我们的延迟加载程序。我们可以轻易地通过重写TestCase类中的setUp和tearDown方法来实现这个要求。我比较喜欢用这个方便的抽象类作为我所有测试类的基类。
　　
　　
　　public abstract class MyLazyTestCase extends TestCase {
　　
　　private SessionFactory sessionFactory;
　　private Session session;
　　
　　public void setUp() throws Exception {
　　super.setUp();
　　SessionFactory sessionFactory = (SessionFactory) getBean("sessionFactory");
　　session = SessionFactoryUtils.getSession(sessionFactory, true);
　　Session s = sessionFactory.openSession();
　　TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(s));
　　
　　}
　　
　　protected Object getBean(String beanName) {
　　//Code to get objects from Spring application context
　　}
　　
　　public void tearDown() throws Exception {
　　super.tearDown();
　　SessionHolder holder = (SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
　　Session s = holder.getSession();
　　s.flush();
　　TransactionSynchronizationManager.unbindResource(sessionFactory);
　　SessionFactoryUtils.closeSessionIfNecessary(s, sessionFactory);
　　}
　　}

团队提升团队培训

2008-11-14T21:18:00.003-08:00

团队提升团队培训

值得分享的一个团队培训小游戏

昨天，在公司内部的培训交流会上，与下属们分享了一个团队培训的小游戏。今天整理工作日志的时候，愈发感觉这个小游戏值得分享一下。不管是从游戏本身，还是从游戏出发的种种目的和结果，都能令人收益匪浅。

先介绍一下这个游戏：

名称：猜猜他是谁？
道具：一叠空白卡片
人数：4－7人。如果有更多参与者，将他们分成人数相等的小组。
游戏过程：
　　1. 事先准备4－6个相关的问题。以我昨天下午的培训为例，准备的六个问题是：
　　（1）你觉得搞这个培训交流会最主要的目的是什么？
　　（2）对这样的培训交流会你最大的担心是什么？
　　（3）你认为目前互联网行业最热的名词是什么？
（4）你认为目前我们所在的行业最大的问题是什么？
　　（5）描述一下自己迷人的程度？
　　（6）说出一位自己喜欢的明星的名字。
　　2. 每人取出一张卡片，写上数字"1"，然后在卡片上写下自己对第一个问题的回答。重复以上步骤，直至答完所有问题。但每张卡片只能有一个问题的答案。将卡片写有答案的一面朝下，放在桌子中间。
　　3. 让一位员工将所有卡片打乱。
　　4. 由第一位员工任意抽取一张卡片，大声念卡片上的内容。如有需要，可再念一遍。但不能将卡片给任何人看，以防从笔迹中辨认出作者。
　　5. 除了朗读者之外，其他员工都猜一猜谁是作者，并由朗读者把大家猜测的名字写下来。（卡片真正的作者不能猜自己，只能随便猜一个另外的人。）
　　6. 记录完之后，每个人轮流解释自己猜测结果地原因。可以有适度的争论。

7. 此时，真正的作者可以揭晓谜底。凡是猜对者均可得一分，把分数记录在黑板上。然后将卡片正面朝上放在桌子中间。
　　8. 下一位再选择一张卡片，进行同样的过程。
　　9. 如果只剩下最后一个针对某一问题的答案，朗读者只需将答案读一遍，然后将卡片放在桌子中间即可。（此次没有必要再猜，因为可通过排除法猜出作者。）
　　10. 结束游戏后，宣布得分最高者获胜。

通过这个小游戏，可以达到很多目的或结果：

第一：可以获悉团队成员之间的相互了解程度。我们成天口口声声讲要团队协作。团队协作的最重要前提是什么？是团队成员之间的相互了解。只有建立了相互了解的前提，我们才可能实现团队协作。如果现在让我和隔壁公司的张三合作，我和张三也就是见面点头打个招呼，至于他有什么样背景经验、有什么样的特长、有什么样的喜好，我一无所知，谈得上合作吗？要协作，必须相互了解达到一个程度。通过这个游戏的过程，我们可以发现团队成员之间的相互了解程度。得分最高者可能在了解别人的地方做的好一些，得分低者可能在了解别人方面做得差一些。

第二：增进同事之间的关爱。通过对作者的猜测，有的成员就会发现原来别人对自己喜欢什么明星、对自己平时说话表达的口气、认识问题的方式等各方面都了解得这么多，而自己却对别人了解甚少，从而激发自己更多的去了解同事、关心同事。其实我们每天的生活中，同事之间是相处最多，交流最多的，甚至超过了自己的爱人或男女朋友。同事是我们最需要珍惜的一类群体。

第三：这个游戏还能以轻松的方式获得我们所需要获得的信息。拿我们昨天的游戏内容来说，以这种游戏的方式，可以更好的了解团队成员对这样的培训交流会的看法和担心。同样，也能帮助团队Leader更好的获悉团队成员对某些与工作和个人生活相关的问题的看法。与其他获取信息的方法相比，这种方法要有效的多。

第四：通过游戏让每个成员清楚了自己被他人了解的程度和他人了解自己的程度。自己的问题被很多人猜对，说明平时自己和同事沟通比较多；自己的问题如果没有一个猜对作者，那证明你被同事了解的程度太低，那就得想想自己是不是平时与同事沟通太少，或者还是自己不善于表达出来。以后如再举行类似的游戏，可以把每次被猜出来的人数的个数作为该作者的分数，可以统计被人了解的得分情况。

第五：游戏还可以锻炼团队成员的逻辑思维能力、表述能力、整理思维的能力。从这个角度讲，这个游戏类似于杀人游戏。

交通阻塞
道具：比参加人数多一个塑胶地垫
说明：
1、将塑胶地垫呈一字型在地上铺开，让学员全部站在地垫上，留中间一个地垫不站人；
2、学员分成两边相对而站，通过中间的空格进行移动，
3、移动的方式是只能前进一格或跳一格，不能后退
4、完成两边人的互换，并且大家维持同一个方向。
规则：
1、学员只能前进不能后退，只要有人后退就要重来
2、当有人知道答案时，我们要每个人都知道答案

迷失丛林
形式：先以个人形式，之后再以5人的小组形式完成
类型：团队建设
时间：30分钟
材料及场地：迷失丛林工作表及专家意见表，教室及会议室
适用对象：所有学员
活动目的：通过具体活动来说明，团队的智慧高于个人智慧的平均组合，只要学会运用团队工作方法，可以达到更好的效果。
操作程序
1、培训师把“迷失丛林”工作表发给每一位学员，而后讲下面一段故事：
你是一名飞行员，但你驾驶的飞机在飞越非洲丛林上空时飞机突然失事，这时你必须跳伞。与你们一起落在非洲丛林中有14样物品，这时你们必须为生存作出一些决定。
2、在14样物品中，先以个人形式把14样物品以重要顺序排列出来，把答案写在第一栏。
3、当大家都完成之后，培训师把全班学员分为5人一组，让他们开始进行讨论，以小组形式把14样物品重新按重要顺序再排列把答案写在工作表的第二栏，讨论时间为20分钟。
4、当小组完成之后，培训师把专家意见表发给每个小组，小组成员将把专家意见转入第三栏。
5、用第三栏减第一栏，取绝对值得出第四栏，用第三栏减第二栏得出第五栏，把第四栏累加起来得出一个个人得分，第五栏累计起来得出小组得分。
6、培训师把每个小组的分数情况记录在白板上，用于分析：

小组全组个人得分团队得分平均分
1
2
3
4

7、培训师在分析时主要掌握两个关键的地方：
1）找出团队得分低于平均分的小组进行分析，说明团队工作的效果（1+1大于2）；
2）找出个人得分最接近团队得分的小组及个人，说明该个人的意见对小组的影响力。
有关讨论：
1、你对团队工作方法是否有更进一步的认识？
2、你的小组是否有出现意见垄断的现象，为什么？
3、你所在的小组是以什么方法达成共识的？

将以下内容打印给学员
　物品清单 1个人顺序 2小组顺序 3专家排列个人和专家比较（3-1）小组与专家比较（3-2）
1 药箱　　　　
2 手提收音机　　　　
3 打火机　　　　
4 三只高尔夫球杆　

5 七个大的绿的垃圾袋　　　　
6 指南针　　　　
7 蜡烛　　　　
8 手枪　　　　
9 药箱一瓶驱虫剂　　　
10 大砍刀　　　　
11 蛇咬药箱　　　　
12 一盒轻便食物　　　　
13 一张防水毛毯　　　　
14 一个热水瓶　　　　
第6步：计算个人得分（第4步总和）
第7步：计算团队得分（第5步总和）
第8步：统计小组中最低个人得分
第9步：计算个人得分低于团队得分的总和
第10步：计算个人得分的平均数

专家选择
药箱6　手提收音机13　　打火机2　　3支高尔夫球杆11　　7个大绿色垃圾袋7　　指南针（罗盘）14　　蜡烛3　　手枪12　　一瓶驱虫剂5　　大砍刀1　　蛇咬药箱10　　一盒轻便食物8　　一张防水毛毯4　　一个热水瓶9

解手链

形式：10人一组为最佳
时间：20分钟
材料：无
适用对象：全体人员
活动目的：让学员体会在解决团队问题方面都有什么步骤，聆听在沟通中的重要性，以及团队的合作精神。
操作程序
1、培训师让每组圈着站成一个向心圈。
2、培训师说：先举起你的右手，握住对面那个人的手；再举起你的左手，握住另外一个人的手；现在你们面对一个错综复杂的问题，在不松开的情况下，想办法把这张乱网解开
3、告诉大家一定可以解开，但答案会有两种。一种是一个大圈，另外一种是两个套着的环。
4、如果过程中实在解不开，培训师可允许学员决定相邻两只手断开一次，但再次进行时必须马上封闭。

有关讨论
你在开始的感觉怎样，是否思路很混乱？
当解开了一点以后，你的想法是否发生了变化？
最后问题得到了解决，你是不是很开心？
在这个过程中，你学到了什么？

瞎子走路

游戏方法：
两人一组（如A与B）
A先闭上眼睛，将手交给B，B可以虚构任何地形或路线，口述注意事项指引A行进。如：“向前走，……迈台阶……跨过一道小沟……向左手拐……”
然后交换角色，B闭眼，A指引B走路
分析：
通过亲身体验，让学员体会信任与被信任的感觉
作为被牵引的一方，应全身心信赖对方，大胆遵照对方的指引行事
而作为牵引者，应对伙伴的安全负起全部的责任，对一举一动的指令均应保证准确、清楚
另外，万一指令有错，信任受到怀疑后很难重建

你说我做

道具：七彩积木
参加人数：20-30人
用时：约1小时
游戏前准备：培训师先自己用积木做好一个模型。
过程：
1、将参加人员分成若干组，每组4-6人为宜。
2、每组讨论三分钟，根据自己平时的特点分成两队，分别为“指导者”和“操作者”。
3、请每组的“操作者”暂时先到教师外面等候。
4、这时培训师拿出自己做好的模型，让每组剩下的“指导者”观看（不许拆开），并记录下模型的样式。
5、15分钟后，将模型收起，请“操作者”进入教室，每组的“指导者”将刚刚看到的模型描述给“操作者”，由“操作者”搭建一个与模型一模一样的造型。
6、培训师展示标准模型，用时少且出错率低者为胜。
7、让“指导者”和“操作者”分别将自己的感受用彩笔写在白纸上。
游戏点评：
1、身为指导者的你，体会到什么？
2、身为操作者的你，体会到什么？
3、当操作者没有完全按照你的指导去做的时候，指导者的你有什么感觉？
4、当感觉到你没能完全领会指导者意图的时候，操作者的你有什么感觉？
5、当竞争对手已经做完，欢呼雀跃的时候，你们有什么感受？
6、当看到最后的作品与标准模型不一样的时候，你们有什么感受？
7、是效率给予的压力大，还是安全性给予的压力大？
8、指导者和操作者感受到的压力有什么不一样？
适用课程：《职业压力》、《团队建设》。

如何建立信任

带眼罩行走，两人一组
第一阶段：一个人带眼罩行走，另一人手牵手，可以提示；
第二阶段：一人带眼罩行走，另一人在其左右，但不能身体接触，也不能使用语言提示；
第三阶段：一人带眼罩行走，另一人与你保持一定距离，不能使用语言提示。
游戏说明：
1．领导行为、观点的连续性、一致性，保持沟通，是信任建立的根本保障
2．手把手教—引导—建立信任，授权，同时不断给予指导

报数

所需时间：30-60分钟，由团队的人数的多少决定，培训者打算用多少时间做此练习。
小组人数：越多越好
所需物品：秒表
游戏概述：一个关于促进团队效率游戏
目的：
1、使团队通过竞争提高他们的效率。
2、使队员看到团队的责任心
步骤：
1、游戏第一步就是将所有参加的人，要求在两分钟之内分成平均分成两组。
2、挑选男女队长各一名，组织团队进行比赛（队长不参加比赛。）
3、教练要求队长宣誓，问三个问题：“有没有信心战胜对手”、“如果失败，敢不敢于面对队员的指责”、“如果失败，愿不愿意承担由此所带来的一切责任”
4、教练宣布比赛规则：
1）全队学员进行报数，速度越快越好；
2）分别进行8轮比赛，

每轮比赛间隔休息3分钟、2分钟（2次）、1分半钟2次、1分钟（2次）
3）每轮比赛进行奖惩。输者，由队长率领队员向对方表示诚服，并对对方队员说：“愿赌服输，恭喜你们！”并有男女队长做俯卧撑10次，如果以后再输，俯卧撑的次数将会乘倍递增。赢者，将全队哈哈大笑，以示胜利。
4）将每轮比赛的结果记录在白板上。
5、游戏结束，播放抒情音乐（熄灯），诵读一篇散文（记述文，并在最后一轮失败的人当中在做俯卧撑的时候，让学员深深感受到责任是一种非常重要的人生）。
6、诵读结束，教练引导大家讨论：
讨论题目：
1、每个人都同意所有的意见吗？如果不是，为什么？
2、谈谈责任心对我们人生的体会？

6盒冰红茶

课间休息，林先生在每个桌子分别放上6盒冰红茶，红的、绿的，煞是好看。但是他说：“先不要喝哦，待会儿我们用它来做个游戏。”
　　30名学员分成4个小组，每两个小组又编成两个竞赛小队。一个竞赛小队中的一个组，背着另一组先将自己桌上的6盒冰红茶摆成任意形状，然后，通过语言描述给同队中的另一组，另一组听到描述后即开始摆放。另一队亦然。10分钟后，哪一组摆放图形最相似，就算哪一队为胜者。

　　6盒冰红茶拼图？太“小儿科”了。我们组的7个人个个是“赛孔明”，14只手把它们摆成一个立体的“天”字，上下三层，前后三层，够水平的吧？再看看另一队的那个组，他们摆了个最简单正六边形，既没有层次，又缺乏“艺术”，真够笨的。正美哩，我们队另一组的阿红着急了：快点说吧，下一步工序是我们听你们的遥控啦！

　　我们这幅够艺术的拼图确实难模仿！7张嘴嚷开了：“有三层”、“是立着的”、“前边不出头”、“两个摆成一横”，……等到阿红她们手忙脚乱地听我们指挥，将6盒冰红茶摆得刚有点模样时，时间到了。

　　大家先一起评判另一队。他们队的两个拼图完全一样，都是立着的正六边形，汉字标签一律朝外，拼音字母一律向内，红、绿颜色相间，字头咬字尾按顺时针有规律地排列。一目了然。

　　再看看我们这一队，大伙儿全乐了，两个组的“天”字怎么比较也不像：一组是红盒，一组是绿盒，一组汉字朝外，一组汉字朝内，一组盒头朝前，一组盒头向后……。

　　最后，当然我们输了。阿红气得直瞪我们：“就你们能耐，自作聪明！”　这时，林先生开始讲解“沟通的技巧”，他说：“上级给下属布置任务，要简单明了，内部流程不要故意弄得很复杂，人为地设置障碍。指令一定要明确，描述一定要到位……”

踩报纸

参加游戏人员在10人以上，在规定的时间（由讲师视人数多少而定）内全部站到1开的报纸上，（特别说明，全部的脚不能站出报纸的边界）
分析：
解决问题的思路要突破限制，要敢于尝试、大胆想象，并善于实验学员的建议，排除不可行的方案

金融经济学家解释

2008-11-14T21:18:00.001-08:00

金融经济学家解释经济名词

一男赶集卖猪，天黑遇雨，二十头猪未卖成，到一农家借宿。

少妇说：家里只一人不便。

男：求你了大妹子，给猪一头。

女：好吧，但家只有一床。

男：我也到床上睡，再给猪一头。

女：同意。

半夜男与女商量，我到你上面睡，女不肯。

男：给猪两头。

女允，要求上去不能动。

少顷，男忍不住，央求动一下，女不肯。

男：动一下给猪两头。女同意。

男动了八次停下，女问为何不动？

男说猪没了。

女小声说：要不我给你猪……

天亮后，男吹着口哨赶30头（含少妇家的10头）猪赶集去了……

哈佛导师评论：要发现用户潜在需求，前期必须引导，培养用户需求，因此产生的投入是符合发展规律的。

另一男得知此事，决意如法炮制，遂赶集卖猪，天黑遇雨，二十头猪未卖成，到一农家借宿

少妇说：家里只一人不便。

男：求你了大妹子，给猪一头

女：好吧，但家只有一床。

男：我也到床上睡，再给猪一头。

女：同意。

半夜男商女，我到你上面睡，女不肯。

男：给猪两头。

女允，要求上去不能动。

少顷，男忍不住，央求动一下，女不肯。

男：动一下给猪两头。女同意。

男动了七次停下，女问为何不动？

男说：完事了～～～女：......

天亮后，男低著头赶2头猪赶集去了.....

哈佛导师评论：要结合企业自身规模进行谨慎投资，谨防资金链断裂问题

又一男得知此事，决意如法炮制兼吸取教训，遂先用一头猪去换一粒伟哥，事必，天亮后，男吹着口哨赶38头（含少妇家的18头）猪赶集去了……

哈佛导师评论：企业如果获得金融资本的帮助，自身经营能力将得到倍增。

知道此法男多，伟哥供不应求，逐渐要2头，3头猪换一粒伟哥。

哈佛导师评论：这就是通货膨胀。

当猪价格涨到16粒一棵的时候，哈佛导师评论：该男已经进入边际成本，除了拥有对自身能力的自信和未来良好愿望以外，实际现猪流已经为零。

但换猪男越来越多，卖伟哥的决定，扩展生产能力，推出一种次级伟哥，如果你缺一头猪，只要你承诺可以到该女房中一夜，就可以先借，事成后补交猪款，这个方法大大促进了伟哥销售。

哈佛导师评论：这就是贷款，让企业可以根据未来的收益选择借支流动资金

伟哥专卖店后来在即使你一头猪都没有，只要你承诺可以到该女房中一夜，就可以先借，事成后补交猪款。

哈佛导师评论：这就是金融创新，让现在的人花未来的钱，反正等你老了未来的钱你也花不动。

消息一出，换猪男越来越多，有人找伟哥专卖店，这个项目太好了，我们把它变成优质基金，对外销售债卷，你们也就可以分享我的收益，如何？结果伟哥专卖店觉得甚好，于是该公司把换猪男分三类，一类是拿现猪换的，一类是一部分现猪贷的，一类是完全没有现猪借的，发行三种债卷。大家踊跃而上。纷纷购买伟哥专卖店的债卷，伟哥专卖店生意太好，就把债卷销售外包给另外一家公司运作，该公司也一并大发其财，公司越做越大，甚至可以脱离实际伟哥销售情况来发行，给自己和伟哥专卖店带来巨大的现金收益。

哈佛导师评论：这就是专业的人做专业的事，从实体经营到资本运作，经济进入了更高的层次。

为了防止自己债卷未来有损失，该公司决定给它买上保险，这样债卷销售就更容易，因为一旦债卷出现问题，还可以获得保险公司的赔付，哇，债券公司销售这下子太好了，保险公司也获得巨大平白无故的保险收入。

哈佛导师评论：这就是风险对冲，策略联盟，提高了企业的抗风险能力，也保护了消费者利益。

换猪男太多，排长队等待，该女无法承受，说老娘不干了，我搬家，一时间有无数拥有伟哥的欠猪男。

哈佛导师评论：这是个别现象，属于市场的正常波动，不会影响整个经济。

结果该女迟迟不肯搬回。一部分欠猪男没有收入，只好赖帐，结果大量债卷到期无法换现猪吃，债卷公司一看，一粒伟哥16头猪，这哪里还得起，宣布倒闭。

哈佛导师评论：这是次贷；换嵊跋煺鼋鹑谛幸怠?/FONT>

哪里晓得债卷公司还把债卷上了保险，保险公司一看，这哪里赔得起，于是也宣布要倒闭。

哈佛导师评论：这是金融危机，还不会影响整个实体经济。

后文：据说该女已搬到中国定居。

教师用机安全管理规定

2008-11-08T22:38:00.001-08:00

北大青鸟APTECH（青岛银河）授权培训中心

教师用机安全管理规定

一、
目的

中心教室、机房的教师用微机及相关外设、网线不允许学员使用；近期中心发现部分学生私自使用教师机、携带个人笔记本电脑接入教师机网线，给中心办公网络安全带来产生隐患；为有效杜绝此问题特制定本规定。

二、
适用范围及责任

本规定适用于中心全体员工，中心技术支持负责具体实施与监督，中心行政专员负责监督考核。

三、
规定

1．中心技术支持:

中心技术支持统一管理教室计算机及其相关设备，保证教室计算机运行良好。在
教师机上安装教学常用软件以及教学用PPT。并且安装硬盘保护卡，保护系统盘。
中心技术支持在教室机器上开设两个帐户，一个给任课教员使用，一个给市场部经理使用，分别设置不同的密码。密码定期修改，修改频率为：月。（密码修改前技术支持必须以邮件形式通知学术、市场经理，经理负责通知相关员工）
检查与监控：技术支持会对全员的密码使用及学员规范进行例行巡检及抽查，并对发现的违规进行通报。

2．任课教员:

具备安全防范意识，要在日常学员管理中教育学员不得使用教师微机及其外设，一旦发现学生违规使用教师机，必须第一时间制止并给与教育。
教员不论何时，离开教室前必须关闭或锁定计算机；
教师不得在教室机器安装新软件，若确为需要安装，经中心技术支持同意后由技术支持安装。
使用教师机的其他员工执行规范同上。

3．班主任:

具备安全防范意识，要在日常学员管理中教育学员不得使用教师微机及其外设，一旦发现学生违规使用教师机，必须第一时间制止并给与教育。
班主任严格按照课程表安排自习教室，及时锁闭空闲教室、机房，确保安全并节约资源。

四、
考核方法

1. 如责任人违反规定，每次给予30元处罚；

2. 如学员违规，第一次口头警告，登记学生姓名；第
2次违规记入学生档案，减少一次就业推荐。

版本日期：2007年11月1日

. 如学员违规被中心技术支持、行政专员、校长发现，在处罚学员的同时，给与学员所在班级的班主任、教员连带处罚每次30元。

this is a test

2008-10-29T22:06:00.001-07:00

this is a test!

2008-01-22T06:13:00.000-08:00

2007-12-06T05:50:00.000-08:00

TOMCAT集群配置

我的运行环境:Windows2003 Server SP4 + J2SDK1.5.0 +Tomcat5.5.9

准备软件:Tomcat 5.5.9 JDK1.5.0

一．配置过程

1、安装JDK1.5.0。采用默认安装就可以。

2、安装tomcat到C: tomcat 50，采用完全安装，该程序用于实现负载均衡功能。

3、将tomcat50的内容进行完全复制，生成C: tomcat 51、C: tomcat 52、C: tomcat 53，分别用做集群中的节点。

4、修改负载均衡规则，使其遵循轮循算法（RoundRobin）。

4.1将testLB.jsp复制到c：tomcat50webappsbalancer文件夹中

4.2将文件夹classes复制到c：tomcat50webappsbalancerWEB-INF文件夹中

4.3修改c:webtomcat50webappsbalancerWEB-INFweb.xml文件如下：

BalancerFilter
/LoadBalancer

5、在集群中每个节点下，部署clusterapp应用。Clusterapp包含sessiondata.jsp，test.jsp，脚本。 test.jsp是用来验证节点状态的页面；sessiondata.jsp是用来响应用户所发送的请求，同时记录会话ID，会话的起始和最后时间，提供用户增加、修改、删除会话的属性字段和属性值，可以通过此来判断会话的持续与否。

6、将log4j的log4j-1.2.9.jar复制到每个％tomcat％/common/ lib下，使其将会话日志统一存储到指定的文件中。

7、修改每个tomcat的server.xml配置文件，参数如下表所示。

配置 Instance 1 Instance 2 Instance 3 Instance 4
Instance Type Load Balancer Node 1 Node 2 Node 3
Code name TC-LB TC01 TC02 TC03
Home Directory c:/tomcat50 c:/tomcat51 c:/tomcat52 c:/tomcat53
Server Port 8005 9005 10005 11005
Connector 8080 9080 10080 11080
JK2 AJP Connector 8009 9009 10009 11009
Cluster mcastAddr 228.0.0.4 228.0.0.4 228.0.0.4 228.0.0.4
Cluster mcastPort 45564 45564 45564 45564
tcpListenAddress 127.0.0.1 127.0.0.1 127.0.0.1 127.0.0.1
Cluster tcpListenPort 4000 4001 4002 4003

8、修改c:webtomcat50webappsbalancerWEB-INFconfigruler.xml文件如下：

serverInstance="1"
maxServerInstances="3"
tcpListenAddress="127.0.0.1"
tcpListenPort="4001"
testWebPage="http://localhost:9080/clusterapp/test.jsp"
redirectUrl="http://localhost:9080/clusterapp/sessiondata.jsp" />

serverInstance="2"
maxServerInstances="3"
tcpListenAddress="127.0.0.1"
tcpListenPort="4002"
testWebPage="http://localhost:10080/clusterapp/test.jsp"
redirectUrl="http://localhost:10080/clusterapp/sessiondata.jsp" />

serverInstance="3"
maxServerInstances="3"
tcpListenAddress="127.0.0.1"
tcpListenPort="4003"
testWebPage="http://localhost:11080/clusterapp/test.jsp"
redirectUrl="http://localhost:11080/clusterapp/sessiondata.jsp" />

redirectUrl="http://localhost:8080/balancer/testLB.jsp" />

9、启动tomcat的应用。手动双击每个tomcat/bin的startup.bat程序。

二．Web请求集群环境下流程

1、启动访问起始页（http://localhost:8080/balancer/testLB.jsp）

2、JSP重定向请求到负载均衡过滤文件（http://localhost:8080/balancer/LoadBalancer）

3、负载均衡的tomcat接受请求，根据制定的负载均衡算法，重定向到可用的集群节点（TC01、TC02、TC03）

4、对应集群中节点的sessiondata.jsp（位于clusterapp应用下）页面将启动。

5、sesiondata.jsp将在web上显示会话的详细信息（如会话ID，最后访问时间）
在测试的过程中采用RoundRobin算法，通过对Instance 1发起多个http://localhost:8080/balancer/testLB.jsp测试请求，发现每个请求返回页面的端口号不完全一致，在 9080、10080、11080端口不规则的出现，即客户端的访问请求按照RoundRobin算法被重定向到不同的服务器上进行处理，说明该负载均衡规则在这个测试中得到正确的体现。在关闭集群中一个节点后再启用它，能够自动发现该节点，并为该节点分配请求。

【责编:Star】

网络上有好多关于 Tomcat 集群配置的文章，但有些是以 Tomcat 4 为基础的，有的并不是讲的很清楚，自己摸索了半天，试验成功了，现把简要过程写出来，让你在几分钟内体验一下 Tomcat Cluster 。

一、配置环境

下载和安装 JRE 1.5 最新版（1.5.06）
下载和安装 Tomcat 最新版（5.5.12），假定安装目录为 C:Program FilesApache Software FoundationTomcat 5.5

二、使 Tomcat 集群配置生效

修改 Tomcat 安装目录confserver.xml ，把 Server/Service/Engine/Host 下的 Cluster 结点前后的注释符（）删除，并保存

三、配置第二个 Tomcat 实例

在 C:Program FilesApache Software Foundation 下新建目录 Tomcat 5.5 Instance1
将 C:Program FilesApache Software FoundationTomcat 5.5 目录下的全部内容复制到 C:Program FilesApache Software FoundationTomcat 5.5 Instance1
修改新实例的服务器配置文件（C:Program FilesApache Software FoundationTomcat 5.5 Instance1confserver.xml），把其中的 Server/Service/Connector 的端口更改，以避免和第一个冲突（8080 -> 9080，8009 -> 9009，8443 -> 9443）
修改 Cluster/Receiver 结点的 tcpListenPort 端口（此端口用于 Session 复制），以避免和第一个冲突（4001 -> 4002）

注：Tomcat Cluster 默认使用多播来建立成员关系，即两个实例的多播的地址和端口一样，就可以互相认为是同一个 Cluster 的成员。

四、启动验证两个 Tomcat 实例能否正常工作

直接用程序菜单里的 Monitor Tomcat 来启动第一个实例（或在服务器里启动）
第二个实例启动稍微麻烦一些，在 C:Program FilesApache Software FoundationTomcat 5.5 Instance1Bin 下建一个 startup.bat ，用如下 java 命令来启动：

"C:Program FilesJavaj实re1.5.0_06binjava.exe" -jar .bootstrap.jar -Dcatalina.home="C:Program FilesApache Software FoundationTomcat 5.5 Instance1" -Dcatalina.base="C:Program FilesApache Software FoundationTomcat 5.5 Instance1" -Djava.endorsed.dirs="C:Program FilesApache Software FoundationTomcat 5.5commonendorsed" -Djava.io.tmpdir="C:Program FilesApache Software FoundationTomcat 5.5 Instance1temp" -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djava.util.logging.config.file="C:Program FilesApache Software FoundationTomcat 5.5 Instance1conflogging.properties" start

看起来挺长，其实主要是第二个实例的安装目录太长的缘故，直接执行此批处理就可以启动第二个实例，如果配置正确，应该可以看到集群管理器启动，并和第一个实例建立成员关系的信息。

五、写一个简单Web应用，能显示和设置 Session 属性值，以供测试

如果有开发工具，新建一个 Web App ，假设为 TomcatDemo
新增 index.jsp ，加入如下代码：

<%...@ page contentType="text/html; charset=UTF-8" import="java.util.*"%> <html><head><title>Cluster App Test</title></head> <body> Server Info: <%... out.print(request.getLocalAddr() + " : " + request.getLocalPort());%> <%...   out.println("<br> ID " + session.getId());

  // 如果有新的 Session 属性设置
  String dataName = request.getParameter("dataName");
  if (dataName != null && dataName.length() > 0) {
     String dataValue = request.getParameter("dataValue");
     session.setAttribute(dataName, dataValue);
  }

  out.print("<b>Session 列表</b>");

  Enumeration e = session.getAttributeNames();
  while (e.hasMoreElements()) {
     String name = (String)e.nextElement();
     String value = session.getAttribute(name).toString();
     out.println( name + " = " + value);
   }
%>   <form action="index.jsp" method="POST">     名称:<input type=text size=20 name="dataName">      <br>     值:<input type=text size=20 name="dataValue">      <br>     <input type=submit>
   </form> </body> </html>

以上代码主要是显示服务器信息和 Session 值，并包含一个 Form ，可以随时新建一个 Session 属性值

修改此用应用的 Web.xml ，加入 distributable 属性，表示 Tomcat 要为此 Web 应用复制 Session

<web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" version="2.4">        <display-name>TomcatDemo</display-name>        <distributable/> </web-app>

将应用打包成 WAR 文件，分别上现两个实例的 Tomcat Manager 来部署

(如果没有 Java 开发工具，可以直接建立一个 TomcatDemo 的目录，用 Notepad 将如上的内容复制并保存成 index.jsp，然后在此目录下新建子目录 WEB-INF，再用 Notepad 新建一 Web.xml 文件，将上面的代码复制保存，然后将此目录压缩成 Zip 文件，再把后缀改成 .war ，或利用 jar 命令来创建 .war 文件）

六、测试 Tomcat 集群和 Session 复制的是否工作

在 IE 中打开第一个实例中的 TomcatDemo （http://localhost:8080/TomcatDemo），在 Form 里随便设置一个 Session 属性，如 MyName = foo
将 IE 地址栏中的地址修改为第二个实例中的 TomcatDemo（http://localhost:9080/TomcatDemo），刷新，就可以看到注意到 SessionID 不变， MyName 的属性值已有了
同样，如果在第二实例中设置的值，在第一个实例的页面中也能看到

注意：必须在同一个 IE 窗口中进行如上测试，以保证是同一个 Session ，如果是两个窗口，则 Session 可能不同，也互相看不到 Session 复制的结果。

七、其它工作

上述只实现了 Session 复制，而没有实现 Load Balance（负载均衡），这可以利用 Apache 等来实现，网上有很多相关文章，可能参考）

2005年12月19日 18:48 - (阅读:3941;评论:16)

# re: QuickStart: Tomcat 集群配置 2006-2-22 9:58 嘉杰

写的很好，很棒！！！

# re: QuickStart: Tomcat 集群配置 2006-2-22 9:59 嘉杰

我顶！！！！！

# re: QuickStart: Tomcat 集群配置 2006-3-24 14:06 java fans

通常cluster都有一个管理节点，tomcat cluster有没有管理与被管理的概念？

# 正要使用之，3Q! 2006-4-12 14:43 Allen

very good!

# re: QuickStart: Tomcat 集群配置 2006-4-30 10:24 lionlhb

写的不错，鼓励一下

# re: QuickStart: Tomcat 集群配置 2006-7-10 14:38 zhj

你这个最终还是需要通过2个入口进入集群有何意义？
难道集群没法配置统一的IP和端口么

# re: QuickStart: Tomcat 集群配置 2006-11-25 17:27 Unmi

很好，我参考了你的这篇文章，用VMWare安装两个操作系统来试验集群功能

to zhj
版主在这篇文章的目的就只是让你体验集群，至于还是需要通过2个入口进入集群，作者已有提到，就是最后的，需要用apache来做负载均衡

# re: QuickStart: Tomcat 集群配置 2006-11-25 18:15 Unmi

我试了，好像不行哦，看来还是需要通过一致的访问入口才能进行Session的复制

# 回复: QuickStart: Tomcat 集群配置 2007-6-6 10:27 zhangv

我也试了一下, 不行的, session id改变了

# 回复: QuickStart: Tomcat 集群配置 2007-6-19 14:17 sessionid变了

你是否打开了两个IE，那么SessionID肯定就变了

# 回复: QuickStart: Tomcat 集群配置 2007-7-30 17:27 开心

非常感谢，我试了可以成功，今天很开心！

# 回复: QuickStart: Tomcat 集群配置 2007-8-10 21:32 Dutchman

谢谢，正要用到！

# 回复: QuickStart: Tomcat 集群配置 2007-11-26 11:58 free1996

写的好,向你学习

# 回复: QuickStart: Tomcat 集群配置 2007-11-26 11:59 free1996

写的好,向你学习,我正在学习中

实践中整理出tomcat集群和负载均衡
(一)环境说明
(1)服务器有4台，一台安装apache,三台安装tomcat
(2)apache2.0.55、tomcat5.5.15、jk2.0.4、jdk1.5.6或jdk1.4.2
(3)ip配置,一台安装apache的ip为192.168.0.88,三台安装tomcat的服务器ip分别为192.168.0.1/2/4
(二)安装过程
(1)在三台要安装tomcat的服务器上先安装jdk
(2)配置jdk的安装路径,在环境变量path中加入jdk的bin路径,新建环境变量JAVA_HOME指向jdk的安装路径
(3)在三台要安装tomcat的服务器上分别安装tomcat,调试三个tomcat到能够正常启动
(4)tomcat的默认WEB服务端口是8080,默认的模式是单独服务,我的三个tomcat的WEB服务端口修改为7080/8888/9999
修改位置为tomcat的安装目录下的conf/server.xml
修改前的配置为
<Connector port="8080" maxHttpHeaderSize="8192"
maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
enableLookups="false" redirectPort="8443" acceptCount="100"
connectionTimeout="20000" disableUploadTimeout="true" />
修改后的配置为
<Connector port="7080" maxHttpHeaderSize="8192"
maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
enableLookups="false" redirectPort="8443" acceptCount="100"
connectionTimeout="20000" disableUploadTimeout="true" />
依次修改每个tomcat的监听端口(7080/8888/9999)

(5)分别测试每个tomcat的启动是否正常
http://192.168.0.1:7080
http://192.168.0.2:8888
http://192.168.0.4:9999
(三)负载均衡配置过程
(1)在那台要安装apache的服务器上安装apache2.0.55,我的安装路径为默认C:Program FilesApache GroupApache2
(2)安装后测试apache能否正常启动，调试到能够正常启动http://192.168.0.88
(3)下载jk2.0.4后解压缩文件
(4)将解压缩后的目录中的modules目录中的mod_jk2.so文件复制到apache的安装目录下的modules目录中,我的为C:Program FilesApache GroupApache2modules
(5)修改apache的安装目录中的conf目录的配置文件httpd.conf，在文件中加LoadModule模块配置信息的最后加上一句LoadModule jk2_module modules/mod_jk2.so
(6)分别修改三个tomcat的配置文件conf/server.xml，修改内容如下
修改前





<Engine name="Catalina" defaultHost="localhost">
修改后



<Engine name="Standalone" defaultHost="localhost" jvmRoute="tomcat1">


将其中的jvmRoute="jvm1"分别修改为jvmRoute="tomcat1"和jvmRoute="tomcat2"和jvmRoute="tomcat3"

(7)然后重启三个tomcat，调试能够正常启动。
(8)在apache的安装目录中的conf目录下创建文件workers2.propertie，写入文件内容如下

# fine the communication channel
[channel.socket:192.168.0.1:8009]
info=Ajp13 forwarding over socket
#配置第一个服务器
tomcatId=tomcat1 #要和tomcat的配置文件server.xml中的jvmRoute="tomcat1"名称一致
debug=0
lb_factor=1 #负载平衡因子，数字越大请求被分配的几率越高

# Define the communication channel
[channel.socket:192.168.0.2:8009]
info=Ajp13 forwarding over socket
tomcatId=tomcat2
debug=0
lb_factor=1

# Define the communication channel
[channel.socket:192.168.0.4:8009]
info=Ajp13 forwarding over socket
tomcatId=tomcat3
debug=0
lb_factor=1

[status:]
info=Status worker, displays runtime information.

[uri:/jkstatus.jsp]
info=Display status information and checks the config file for changes.
group=status:

[uri:/*]
info=Map the whole webapp
debug=0
(9)在三个tomcat的安装目录中的webapps建立相同的应用,我和应用目录名为TomcatDemo,在三个应用目录中建立相同 WEB-INF目录和页面index.jsp,index.jsp的页面内容如下
<%@ page contentType="text/html; charset=GBK" %>
<%@ page import="java.util.*" %>
<html><head><title>Cluster App Test</title></head>
<body>
Server Info:
<%
out.println(request.getLocalAddr() + " : " + request.getLocalPort()+"<br>");%>
<%
out.println("<br> ID " + session.getId()+"<br>");

// 如果有新的 Session 属性设置
String dataName = request.getParameter("dataName");
if (dataName != null && dataName.length() > 0) {
String dataValue = request.getParameter("dataValue");
session.setAttribute(dataName, dataValue);
}

out.print("<b>Session 列表</b>");

Enumeration e = session.getAttributeNames();
while (e.hasMoreElements()) {
String name = (String)e.nextElement();
String value = session.getAttribute(name).toString();
out.println( name + " = " + value+"<br>");
System.out.println( name + " = " + value);
}
%>
<form action="index.jsp" method="POST">
名称:<input type=text size=20 name="dataName">
<br>
值:<input type=text size=20 name="dataValue">
<br>
<input type=submit>
</form>
</body>
</html>
(10)重启apache服务器和三个tomcat服务器,到此负载均衡已配置完成。测试负载均衡先测试apache,访问http://192.168.0.88/jkstatus.jsp
能否正常访问，并查询其中的内容，有三个tomcat的相关配置信息和负载说明,访问http://192.168.0.88/TomcatDemo/index.jsp看能够运行,
能运行，则已建立负载均衡。
(四)tomcat集群配置
(1)负载均衡配置的条件下配置tomcat集群
(2)分别修改三个tomcat的配置文件conf/server.xml,修改内容如下
修改前

修改后

<Cluster className="org.apache.catalina.cluster.tcp.SimpleTcpCluster"
managerClassName="org.apache.catalina.cluster.session.DeltaManager"
expireSessionsOnShutdown="false"
useDirtyFlag="true"
notifyListenersOnReplication="true">

<Membership
className="org.apache.catalina.cluster.mcast.McastService"
mcastAddr="228.0.0.4"
mcastPort="45564"
mcastFrequency="500"
mcastDropTime="3000"/>

<Receiver
className="org.apache.catalina.cluster.tcp.ReplicationListener"
tcpListenAddress="auto"
tcpListenPort="4001"
tcpSelectorTimeout="100"
tcpThreadCount="6"/>

<Sender
className="org.apache.catalina.cluster.tcp.ReplicationTransmitter"
replicationMode="pooled"
ackTimeout="5000"/>

<Valve className="org.apache.catalina.cluster.tcp.ReplicationValve"
filter=".*.gif;.*.js;.*.jpg;.*.png;.*.htm;.*.html;.*.css;.*.txt;"/>

<Deployer className="org.apache.catalina.cluster.deploy.FarmWarDeployer"
tempDir="/tmp/war-temp/"
deployDir="/tmp/war-deploy/"
watchDir="/tmp/war-listen/"
watchEnabled="false"/>

<ClusterListener className="org.apache.catalina.cluster.session.ClusterSessionListener"/>
</Cluster>

将集群配置选项的注释放开即可，如上。
(3)重启三个tomcat。到此tomcat的集群已配置完成。

(五)应用配置
对于要进行负载和集群的的tomcat目录下的webapps中的应用中的WEB-INF中的web.xml文件要添加如下一句配置
<distributable/>
配置前
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" version="2.4">
<display-name>TomcatDemo</display-name>
</web-app>
配置后
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" version="2.4">
<display-name>TomcatDemo</display-name>
<distributable/>
</web-app>

问:tomcat集群是怎么处理session的阿

答:在tomcat做集群之后，每个tomcat之间自动根据tomcat的配置文件中的参数进行session复制,
对于一个客户端对说，只要是同一个IP，那它每次上传的sessionID就是一样的,

1.使用DNS轮询.2.使用Apache R-proxy方式。3.使用Apache mod_jk方式. DNS轮询的缺点是，当集群中某台服务器停止之后，用户由于dns缓存的缘故，便无法访问服务，必须等到dns解析更新，或者这台服务器重新启动。还有就是必须把集群中的所有服务端口暴露给外界，没有用apache做前置代理的方式安全，并且占用大量公网IP地址，而且tomcat还要负责处理静态网页资源，影响效率。优点是集群配置最简单，dns设置也非常简单。 R-proxy的缺点是，当其中一台tomcat停止运行的时候， apache仍然会转发请求过去，导致502网关错误。但是只要服务器再启动就不存在这个问题。 mod_jk方式的优点是，Apache 会自动检测到停止掉的tomcat，然后不再发请求过去。缺点就是，当停止掉的tomcat服务器再次启动的时候，Apache检测不到，仍然不会转发请求过去。 R-proxy和mod_jk的共同优点是.可以只将Apache置于公网，节省公网IP地址资源。可以通过设置来实现Apache专门负责处理静态网页，让Tomcat专门负责处理jsp和servlet等动态请求。共同缺点是：如果前置Apache代理服务器停止运行，所有集群服务将无法对外提供。R-proxy和mod_jk对静态页面请求的处理，都可以通设置来选取一个尽可能优化的效果。这三种方式对实现最佳负载均衡都有一定不足， mod_jk相对好些，可以通过设置lbfactor参数来分配请求任务。所有这些在实际使用中都应该根据具体情况来选择。简略配置如下:前期准备： 1。下载Apache和Tomcat:Apache2.0.53:http: //www.eu.apache.org/dist/httpd/binaries/win32/apache_2.0.53-win32-x86-no_ssl.msi Tomcat5.5.9: http://www.eu.apache.org/dist/jakarta/tomcat-5/v5.5.9/bin/jakarta-tomcat- 5.5.9.ziphttp://www.eu.apache.org/dist/jakarta/tomcat-5/v5.5.9/bin/jakarta -tomcat-5.5.9-fulldocs.tar.gzhttp://www.eu.apache.org/dist/jakarta/tomcat -5/v5.5.9/bin/jakarta-tomcat-5.5.9-compat.ziphttp://www.eu.apache.org/dist/jakarta/tomcat -5/v5.5.9/bin/jakarta-tomcat-5.5.9-admin.zip mod_jk.sohttp://www.eu.apache.org/dist/jakarta/tomcat -connectors/jk/binaries/win32/jk-1.2.8/mod_jk-1.2.8-apache-2.0.52.so(可选，因为Apache2.0.53已经自带). 2.配置Tomcat集群。同时发布有clusterapp这个web应用，，修改test.jsp，使得打开：http://192.168.9.235:12080/clusterapp/test.jsp和http://192.168.9.226: 12080/clusterapp/test.jsp看到的是不同的页面效果。 3.安装Apache2.0.53。此时Tomcat集群的服务器为： 192.168.9.226:12080和192.168.9.235:12080 编辑c: /windows/system32/drivers/etc/host文件，最后一行加上127.0.0.1 lizongbo.com先来R-proxy方式。接下来是mod_jk方式。重新启动apache，同样打开http: //lizongbo.com/clusterapp/test.jsp不停的刷新这个页面，也将会看到页面显示出不同的内容。参考资料：Tomcat cluster:http://www.onjava.com/onjava/2004/04/14/examples/tomcatclustering.ziphttp: //www.onjava.com/pub/a/onjava/2004/11/24/replication1.htmlhttp://www.onjava.com/pub/a/onjava/2004/11/24/replication1.html? page=2http://www.onjava.com/pub/a/onjava/2004/04/14/clustering.htmlhttp://www.onjava.com/pub/a/onjava/2004/04/14/clustering.html? page=2R-proxy:http://www.douzhe.com/docs/ApacheManual/mod/mod_proxy.html#proxypassreversehttp: //www.douzhe.com/docs/ApacheManual/mod/mod_rewrite.html#rewritemaphttp://www.douzhe.com/docs/ApacheManual/mod/mod_rewrite.html#rewriterule mod_jk: http://jakarta.apache.org/tomcat/connectors-doc/config/apache.htmlhttp://jakarta.apache.org/tomcat/connectors -doc/config/workers.htmlhttp://jakarta.apache.org/tomcat/connectors-doc/common/ajpv13a.htmlhttp: //www.mail-archive.com/tomcat-user@jakarta.apache.org/msg146787.html 相对已经过时的资料（因为mod_jk2方式已经不被推荐，mod_jk2已经不再被更新了）：http: //www.sentom.net/list.asp?id=14http://www.linuxforum.net/docnew/showthreaded.php? Cat=&Board=server&Number=507&page=1&view=collapsed&sb =5&o=all&fpart=http://www.ecoo.net/list.asp?articleid=2311http://www.linuxaid.com.cn/forum/showdoc.jsp? l=1&i=81013&m=0http://search.csdn.net/expert/topicview1.asp?id=1706745http: //www.chinaitlab.com/www/news/article_show.asp?id=11921 可能有用的资料：（因为我还没有仔细看过） http://www.phpv.net/article.php/92 http: //raibledesigns.com/tomcat/ http://www.crazysquirrel.com/debian/tomcat55.php

2007-08-21T01:35:00.000-07:00

Struts+Spring+JDBC　简单配置

项目需要，在原来Struts的基础上，配了Spring，数据库访问也用JDBC代替，由于Spring出色的控制反转，JDBC连接的工作基本上不需要考虑，只要专注于数据抽取就可以了，下边把代码贴一下，顺便说说一些小细节。

Spirng和Struts结合，主要有三种方式：
1，使用ActionSupport类
2，覆盖RequestProcessor
3，将Action委托给Spring
文章<使用 Spring更好地处理Struts动作>中,对这三种方法都分析得比较详细,我在这里归纳一下.
使用第一种方法,是最简单的,不需要其他任何配置,只需要在把继承Action,改成继承ActionSupport,带来的问题就是Struts与 Spring,紧耦合,以后不使用Spring配置时,需要修改代码.但其实,我目前觉得使用此方法,有一个好处是可以方便的得到 WebApplicationContext对象,不然,就需要使用ClassPathXmlApplicaiton("...")来取得Context 对象,不是很方便.其实,看DelegationActionUtils的源码,applicationContext对象也只是,这样子通过 sturts的plugin取得的.
actionServlet.getServletContext().getAttribute(
ContextLoaderPlugIn.SERVLET_CONTEXT_PREFIX + modulePrefix)

第二种方法,所有Action的分发都是通过ActionServlet的，而实际上的操作是由RequestProcessor 完成的，因此，可以把它覆盖，引入Spring
The RequestProcessor is where the majority of the core processing occurs for each request. Since version 1.3, the default Request Processor (ComposableRequestProcessor) is composed using Jakarta Commons Chain, which is an implementation of the Chain of Responsibility pattern (CoR).

The <controller> element allows you to configure the ActionServlet. Many of the controller parameters were previously defined by servlet initialization parameters in your web.xml file but have been moved to this section of struts-config.xml in order to allow different modules in the same web application to be configured differently.

第三种是最推荐的方法
顺便说一下,plugin在struts的概念，来自UserGuide：
The PlugIn interface extends Action and so that applications can easily hook into the ActionServlet lifecycle. This interface defines two methods, init() and destroy(), which are called at application startup and shutdown, respectively. A common use of a Plugin Action is to configure or load application-specific data as the web application is starting up.
其中Spring中的ContextLoaderPlugIn就是继承此PlugIn ,从而引入了Spring

基本上这样子就可以把Spring+Struts配置好，然后Spring+JDBC,关键就是配置好DataSource，然后通过JdbcTemplate类，就可以很方便的进行配置．以下部分为代码：

web.xml

<web-app>

<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml,/WEB-INF/applicationContext-*.xml</param-value>
</context-param>

<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<servlet>
<servlet-name>action</servlet-name>
<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
<init-param>
<param-name>config</param-name>
<param-value>/WEB-INF/struts-config.xml</param-value>
</init-param>
<init-param>
<param-name>debug</param-name>
<param-value>3</param-value>
</init-param>
<init-param>
<param-name>detail</param-name>
<param-value>3</param-value>
</init-param>
<load-on-startup>0</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
</web-app>

struts-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.1//EN" "http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd">

<struts-config>
<data-sources />
<form-beans>
<form-bean name="reportBaseForm"
type="com.sjtu.wgq.framework.controller.ReportBaseActionForm">
</form-bean>
</form-beans>
<global-exceptions />
<global-forwards />
<action-mappings>
<action name="reportBaseForm" path="/reportBaseAction"
type="org.springframework.web.struts.DelegatingActionProxy">
<forward name="success" path="/success.jsp"></forward>
<forward name="fail" path="/fail.jsp"></forward>
</action>
</action-mappings>
<message-resources
parameter="com.sjtu.wgq.framework.ApplicationResources" />
<plug-in
className="org.springframework.web.struts.ContextLoaderPlugIn">
<set-property property="contextConfigLocation"
value="/WEB-INF/action-servlet.xml" />
</plug-in>
</struts-config>

action-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean name="/reportBaseAction" class="com.sjtu.wgq.framework.controller.ReportBaseAction"></bean>
</beans>

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName"
value="oracle.jdbc.driver.OracleDriver">
</property>
<property name="url"
value="jdbc:oracle:thin:@IP:端口：SIN">
</property>
<property name="username" value=""></property>
<property name="password" value=""></property>
</bean>
</beans>

applicatoinContext-dao.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="userDAO" class="com.sjtu.wgq.dao.jdbc.UserJdbcTemplateDAO">
<property name="dataSource">
<ref bean="dataSource" />
</property>
</bean>
</beans>

UserDAO.java

public interface UserDAO ...{
public List getUser(String uid);
}

User.java

public class User ...{

String name;
String pwd;

public String getName() ...{
return name;
}
public void setName(String name) ...{
this.name = name;
}
public String getPwd() ...{
return pwd;
}
public void setPwd(String pwd) ...{
this.pwd = pwd;
}
}

UserJdbcTemplateDAO.java

public class UserJdbcTemplateDAO extends JdbcDaoSupport implements UserDAO...{

public List getUser(String uid)...{
if(uid!=null&& !uid.equals(""))...{
String sql = "select ba.USER_ID id ,ba.PSWD_NO no from Ba.Ba9040 ba where ba.USER_ID= " +uid;
//this.getJdbcTemplate().queryForList(sql);
return this.getJdbcTemplate().query(sql,new UserRowMapper());
}
return null;
}

private class UserRowMapper implements RowMapper...{
public Object mapRow(ResultSet rs,int index)throws SQLException...{
User user =new User();
user.setName(rs.getString("id"));
user.setPwd(rs.getString("no"));
return user;
}
}
}

ReportBaseAction.java

public abstract class BaseAction extends ActionSupport {

/** 继承与ActionSupport,
* @see org.apache.struts.action.Action#execute(org.apache.struts.action.ActionMapping, org.apache.struts.action.ActionForm, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
*/
public final ActionForward execute(ActionMapping mapping,ActionForm actionForm,
HttpServletRequest request, HttpServletResponse response) {
ApplicationContext ctx = this.getWebApplicationContext();
//Spring完成注入和初始化．
UserDAO userDao = (UserDAO)ctx.getBean("UserDAO");
//调用UserDAO接口声明的方法．
//userDAO.getUser("1");
}
}

ActionForm的部分就省略了．
另外提一下就是，ActionSupport的getWebApplicatoinContext()方法载入的xml文件，是要在web.xml的<context-param>声明的，否则如果只在struts-config.xml声明会找不到的．因为两个声明的不是一个概念，在getWebApplicatoinContext是通过servlet.getContext 的方法找到的，而在struts-config.xml配置的只是action-servlet.xml，即action的内容．具体原因，我还没有去查．

另外就是关于多个applicationContext的问题，可以参考web.xml的配置就可以了．
还有，applicationContext-dao.xml中的UserDao引用了dataSource,因为不在同一文件中，所以用<bean ref="">的格式，如果在同一文件可以用<bean local="">来引用．

通过Spring，使得Struts更加灵活，JDBC的配置很简单，但配置文件多，而且因为applicatonContext配置不正确的话，web工程是无法启动的，报linstener的错误，但不会具体指出是什么错．

还有以下问题要看看资料：
1,为什么在plugin里配置的xml，无法在getWebApplication中得到，按道理应该是一致的，因为都是通过actoinservlet去取得信息．
2,RequestProcessor具体是怎么工作的．

下次把＜程序员面试指南＞的体会说一下．

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

首先是一个基类BaseAction
=================================================================
public class BaseAction extends ActionSupport {
/** 简单的得到spring bean的方法*/
public Object getBean(String beanName) {
return this.getWebApplicationContext().getBean(beanName);
}

/** 由子类Action对象调用, 可以在初始化时反射自身的结构, 形成一个映射, 用来日后dispatchSubaction.
*
* @return 存放了methods对象的Map
*/
protected Map getMethodMap() {
......
}

/** 将Action转移给子动作.
* 在子类中调用时，只需要新建一个Object[] {参数1, 参数2, ...} 一般为 {form, request, dao}
* 然后调用dispatchSubAction(String, objects) 即可
*
* @param action 字符串，决定子动作的方法名
* @param objs 参数对象列表
* @param methods 由getMethodMap得到的Map
* @return 用来findForward的别名
*/
protected String dispatchSubAction(String action, Object[] objs, Map methods) throws Exception {
......
}

之后是子类的写法：
================================================================
public class SomeAction extends BaseAction {
protected Map methods = getMethodMap(); //各线程公用
//--------- 下面是此Action中公用的一些对象，线程安全？
XxxDAO xxxDao=(XxxDAO) getBean("xxxDao");
XxxService xxxService = (XxxService) getBean("xxxService");

public ActionForward execute(......) throws Exception {
// ===================== 初始化环境 ===================== \
XxxForm form = (XxxForm) actionForm;
ActionErrors errors = new ActionErrors();

// ==================== 获取用户参数 ==================== \
//主要是进行数据转换如：form.setXxx() = form.getXxx().split("..");

// ==================== 调用业务逻辑 ==================== \
Object[] params = {form, request, errors};
//这里的params要和下面定义的所有子程序的参数对应起来
String forward = dispatchSubAction(form.getSubaction(), params, methods);

// ==================== 设置回传参数 ==================== \
saveErrors(request,errors);
return mapping.findForward(forward);
}

//所有的子程序的参数声明都应该相同, 但是每个Action可以根据自己的情况有所区别
public String show(MonthDayExecuteForm form, HttpServletRequest request, ActionErrors errors) {
......
return "show";
}

public String edit(MonthDayExecuteForm form, HttpServletRequest request, ActionErrors errors) {
......
return "edit";
}

public String save(MonthDayExecuteForm form, HttpServletRequest request, ActionErrors errors) {
......
return "show";
}
}
================================================================
归纳：我知道struts有lookupDispatchAction，1.2还有MappedAction，但是那些东西使用起来都不太方便。
1. 有的需要在MessageResources里面进行Submit按钮文字定义。
2. 有的需要在config中有特殊的配置
3. 必须使用和execute完全相同的冗长的函数声明
4. 各方法之间没有交集，难以实现统一的log处理，代码重复写的太多，例如一个简单的XxxForm form = (XxxForm) actionForm; 就必须写在所有的子方法中。

不知道我这样做能不能较好的解决上面的问题？虽然会带来一些初始化的负担，但是实际运行时应该不会怎么影响效率。我主要关心的是，这个结构还可不可以优化？另外有没有什么安全/效率方面的硬伤？望高手们多多指点！