<![CDATA[汐忆时空:CHIRS:蝶衣人生]]> http://zhoujin.com/index.php zh-cn http://zhoujin.com/post/151/ <![CDATA[近期操作题材及关注点]]> chirs <> Tue, 31 Aug 2010 03:48:28 +0000 http://zhoujin.com/post/151/ 市场暂时不具备有效突破2700点动力也不具有下跌动能，箱型格局下做好个股是重点，题材上主力主要是对锂电、医药，消费双节等题材逐步深挖。
在关注题材的同时更要关注技术位置，技术位置不安全题材再好也不要去追，技术位置安全题材差点还可以潜伏。
到九月中旬之后则要留意宏观上的变化，届时市场有变盘可能。 ]]> http://zhoujin.com/post/150/ <![CDATA[兴趣？]]> chirs <> Thu, 01 Jul 2010 08:00:54 +0000 http://zhoujin.com/post/150/
“小时候我很喜欢音乐的，唱歌很好，老师经常夸我。我自己也很喜欢唱歌。可是后来上大学的时候家里人不让我报考音乐学院……”

结果呢，我看到的是基本被搁置一边的天赋，和大量的时间用来看花边新闻八卦杂志研究时尚美容等等等等。

“其实我是个写代码的。我不应该在这里，应该在一个角落里快乐的编写着代码。”

结果呢，我看到的是在真正需要写代码的时候，表现出来的迟钝和生疏。

我也看到很多很多时常将兴趣挂在嘴边，行动上却吝惜投入的人。相信你也看到。或者你就是。

兴趣是一种信仰。

当你真的觉得某些事情是你真正热爱的方向的时候，就应当真正的花时间去追求。原地期待不会有任何结果，朝三暮四更不会。朝九晚五然后说没有时间不是借口，全力投入的一两个小时的产出将远远超出你的想象。

我曾经劝说过很多人，放弃平凡的工作去追求自己真正热爱的人和事。然而真正接受建议的人很少。四平八稳往往是大多数人的选择。很多时候激情、冲动、莽撞之间划上约等号，弄的人搞不清楚这股情绪到底是什么。年长者考虑太多，出于善意，他们往往会说，

“年轻人，别冲动。”

可是，不冲动，是年轻人么？！

兴趣是一种信仰。而信仰要体现力量，需要长时间的近乎虔诚的朝拜和练习。整天挂在嘴边的兴趣不是兴趣。天天练习，以此为生活准则和行为习惯，并且得到广泛认可的小有所成，那才是真正的兴趣。
Tags - , , , ]]> http://zhoujin.com/post/149/ <![CDATA[地球上有一个很奇怪的国家]]> chirs <> Mon, 07 Jun 2010 01:56:00 +0000 http://zhoujin.com/post/149/ 2.该国房子可以是自己的，但土地永远是国家的！最近又补充了一下：“房子是土地的一部分”！
3.该国的国际长途，从国内打到国外的价格是国外打到国内价格的10倍以上！
4.该国说“教育兴国”，“教育是根本”……，但教育经费投入之少与非洲穷国乌干达看齐，百姓自掏教育经费之多全球之冠！此谓优越性！
5.该国公务员的薪水不拿全国的平均水平，而是平均水平的3倍以上，此谓 “高薪养廉”；
6.该国全国公务员不交一分钱“养老金”，而退休后的养老金是全国其他人民的3倍以上。小泉纯一郎3个月没缴“养老金”，电视台作为丑闻天天放！此谓“百步笑三步”。
7.该国有很多企业叫国有企业，书上写公有制度下的国有企业是属于全国人民的。（老百姓不但没有拥有该企业，反而被其垄断的性质不断压榨）
8.禁止收看外国的电视节目！—（比塔利班的禁止收看电视可能要仁慈一点）
9.在这里开车撞了人最好确认撞死再报警，这样责任更小
10.在国内旅游也需要“签证”
11.反对。。。。就要坐牢
12.上市公司诈骗，股民受损失，但国家法院不受理此类赔偿！--（因为无法可依）
13.禁止用自己买下的房子来作公司办公室
14.去网吧上网要出示身份证。
15.黄色刊物属于非法，但性用品商店到处都是。
16.摩托车的行驶证（牌照）价格比摩托车本身高上好几倍。
17.在国外能够浏览的互联网内容在该国可能就无法浏览--（不是你的电脑故障）
Tags - , , , , ]]> http://zhoujin.com/post/148/ <![CDATA[号外：中国机构获微软授权查看Win7大部分源码]]> chirs <> Wed, 02 Jun 2010 08:53:12 +0000 http://zhoujin.com/post/148/
但是，如果是一个长期合同，结果截然不同。任何一方要有伤害对方的举动，对方都会有时间找出机会来进行报复。其结果是，双方都会尽量从对方的角度来考虑问题，从长远的角度来考虑得失。因此，长期合作最后可能产生双赢的结果。

先说博弈论，主要是中国机构获微软授权查看Win7大部分源码。我就在想，这个动作是不是说，微软把操作系统的源代码托管到了中国信息安全测评中心，因为微软要应用到涉密的国家单位，就必须要向相关部门表明自己心中没鬼，自己的软件产品经得起测评考验。一些知名的金融机构也要求信息系统的提供方将源代码托管到第三方那里，因为它们一怕供应商在软件里暗中捣鬼，窃取商业机密；二怕供应商因意外事件停止提供服务，从而导致金融机构的客户服务瘫痪。

素不知道在我们天朝这帮人能看懂吗？这东西又不是看美女，看一眼就心醉。

此中心做过的事，发表的评测网上太多了。里面的叫兽也很多的。砖家也不少的。所以不多说了。

其他不讲绝大部分包括那些。是外围的包括核心的吗？

当然了这个又是一个不能细说的，也不能深说的了。

引用
6月2日下午消息，微软中国今天发布消息称，该公司日前已与中国信息安全测评中心续签了新一期的政府安全计划源代码协议。微软称，该中心和相关被授权机构 将被允许查看包括Windows 7, Windows Server 2008 R2在内的微软产品和平台源代码以及相关技术信息，从而提高中国政府对微软产品安全方面的分析和测评能力。
此协议的签订和实施是国家发展改革委员会与微软公司2006年4月共同签署的关于加强软件产业合作备忘录(二期)的重要组成部分。国家发展改革 委高技术产业司副巡视员徐建成、中国信息安全测评中心主任吴世忠和微软公司全球副总裁Scott Charney等当天出席了签字仪式。
根据签署的新协议，中国信息安全测评中心和相关被授权机构将可以在线即时查看包括Windows 7, Windows Vista、Windows XP、Windows Server 2008 R2, Windows Server 2003、Windows 2000和Windows嵌入式CE 6.0、5.0版、4.2版的专业版源代码包(“PSK”)以及Microsoft Office 专业版2003、Microsoft Office系统中的任何附加产品等在内的微软产品的绝大部分现有版本源代码和相关技术信息。
。。。。。。。。。。。
微软的消息未指明“绝大部分”的具体范围。

国家发展和改革委高技术产业司副巡视员徐建平表示，希望微软公司与中国合作伙伴本着互利共赢的原则在信息安全领域进一步深化合作。

Tags - , , , ]]> http://zhoujin.com/post/147/ <![CDATA[Tomcat 7 即将发布，支持 Servlet 3.0]]> chirs <> Fri, 28 May 2010 06:46:03 +0000 http://zhoujin.com/post/147/
Tomcat 7中最让人兴奋的就是对Servlet 3.0的支持。更多Servlet 3.0的介绍可以查阅读次文章：
http://zhoujin.com/post/146/

除此之外，还支持JSP 2.2和EL 2.2，但是不支持该范围以外的其他Java EE6特征。当然，你可以通过增加所需要的库文件，达到你所需要的目的。

另外有针对64位优化版本。

apache-tomcat-[version].zip or .tar.gz
Base distribution. These distributions do not include the Windows service wrapper nor the compiled APR/native library for Windows.
apache-tomcat-[version].exe
32-bit/64-bit Windows installer for Tomcat.   Please note that while this distribution includes the vast majority of the base distribution, some of the command-line scripts for launching Tomcat are not included. This distribution is intended for those users planning to launch Tomcat through the Windows shortcuts or services.
apache-tomcat-[version]-windows-x86.zip
32-bit Windows specific distribution that includes the Windows service wrapper and the compiled APR/native library for use with 32-bit JVMs on both 32 and 64 bit Windows platforms.
apache-tomcat-[version]-windows-x64.zip
64-bit Windows specific distribution that includes the Windows service wrapper and the compiled APR/native library for use with 64-bit JVMs on x64 Windows platforms.
apache-tomcat-[version]-windows-i64.zip
64-bit Windows specific distribution that includes the Windows service wrapper and the compiled APR/native library for use with 64-bit JVMs on Itanium 64-bit Windows platforms.
apache-tomcat-[version]-deployer.zip or .tar.gz
The standalone Tomcat Web Application Deployer.
apache-tomcat-[version]-fulldocs.tar.gz
The Tomcat documentation bundle, including complete javadocs.

现在，Apache官方网站上还没有提供Tomcat7的下载.


Tags - , , ]]> http://zhoujin.com/post/145/ <![CDATA[生活之痛]]> chirs <> Wed, 19 May 2010 03:04:44 +0000 http://zhoujin.com/post/145/
85%人这个在国家颇受关注的群体当然也难逃税收的折磨，当你还在学校内还感受不到，但在毕业的那一刻，它便与你终生伴随直到生命的终结；大多数的学生都希望能够毕业后找到一份好工作，然后努力的工作，然后买房、买车、结婚、生育，这看似很正常的事情却是一个将我们拖向泥沼的陷阱，当然这不是说这些事情不能做，而是说这些目标在找一个好工作的前提下是一个陷阱，因为你的工资是无法将这些目标一个个的实现，必须通过各种各样的贷款来完成，而你却要在每个月的工资中不断减少可流动的资金，并且为贷款偿还利息，虽然你可能努力的工作得到了更高的薪水和职位，但税收却同样也拿走了更多的钱，生活可能过的不如自己一个人的时候，当你有一个可爱的孩子的时候，你的压力会更大，它将花费掉比房子和车子更多的金钱，并且还会花费掉你更多的精力（如果你是一个称职的的父母），你为了孩子的需要可能会更加的努力的工作以便获得更多的报酬，这样变形成了一个恶性的循环 【工作->消费->贷款->工作】，这样看来一个好的工作并不能达到一个好的结果，当你认知到国家机器和税收的力量以后。

85%人之痛在于处于无产阶级的上层，而中国的绝大部分税收来源于这个阶级，而有钱人都有避税的方法，而唯独我们这个阶级没有，而我们却一直为一个恶性循环结果的目标而奋斗着——“一个好工作”

可悲之处在于我们有知识却没有好结果，可怜之处我们却对一个恶性循环的目标抱有相当坚定的态度。
Tags - , , , ]]> http://zhoujin.com/post/144/ <![CDATA[事关信仰]]> chirs <> Sat, 15 May 2010 01:41:14 +0000 http://zhoujin.com/post/144/
我越来越悲哀的看到，信仰的缺失成为整个时代的悲剧。诱惑太多，扩张太快，进度太紧，组织的成功建立在无数的人放弃自己信仰的基础上，无数人放弃了自己的直觉，挣扎、痛苦中直至麻木。追求完美难道不是每个人天生的直觉吗？对新生事物保持如婴儿般的新鲜感难道不是每个人的直觉吗？对重复的抵制难道不是每个人的直觉吗？

不坚持，无信仰。

如果不曾在悲哀中咀嚼过面包
不曾在哭泣中等待过明天
这样的人就不知道你
－－天的力量

We can face our problem.
We can arrange such facts as we have with order and method.
我们能够面对我们的问题。
我们可以搞定它们，因为我们有规则和方法。
Tags - , ]]> http://zhoujin.com/post/143/ <![CDATA[美国培养出来的中国女孩]]> chirs <> Mon, 10 May 2010 13:15:42 +0000 http://zhoujin.com/post/143/ TED讲座：成年人能从孩子那里学到什么?

此处包含一个多媒体文件，请用网页方式查看。

美国8岁华裔女童邹奇奇4岁开始用电脑创作，上个月出版了第一本英文着作，立刻成为美国文坛新秀，奇奇每分鐘可以打80个字，手指就像在键盘飞一样，奇奇说，新书取名为「飞扬的手指」，是因为她每分鐘可以打80个字，「我的手指就像在键盘上飞一样」。
怎么开发的智力呀？？？
Tags - , ]]> http://zhoujin.com/post/142/ <![CDATA[利用SSH代理爬墙]]> chirs <> Tue, 04 May 2010 00:51:09 +0000 http://zhoujin.com/post/142/
配置方法：
connection –> SSH  –> Tunnels项下增加一动态端口转发选项，Source port中填入本机要监听的端口，选”Dynamic”，然后再点Add就添加成功了。对于Port forwarding里的Loal ports accept connections from other hosts选项，如果你选中该选项的话，将映射本地所有端口到服务器上，默认只是映射你指定的端口。
点击在新窗口中浏览此图片
接着在浏览器里添加代理即可
点击在新窗口中浏览此图片
linux下配置方法：

sudo apt-get install putty

plink -C -D 127.0.0.1:1080 -N -pw 密码 用户名@服务器地址

用系统自带的SSH亦可:

ssh -CfNg -D 127.0.0.1:1080 用户名@服务器地址

Mac下方法一样:

ssh -CfNg -D 127.0.0.1:1080 用户名@服务器地址

不过在我用自己的DremaHost做SSH代理的时候，对于FaceBook和Twitter之类的网站还是无法打开，发现原来网站的DNS解析被河蟹了，所以通过SSH代理也是无法解决的，所以要更改DNS解析才行。我们可以直接使用服务端来进行DNS解析，不过目前我发现只有FireFox支持远端DNS解析，在about:config里，改写
network.proxy.socks_remote_dns=true 就行了。

至于chrome貌似要同过Proxy Switchy这个插件才能解决，其实Firefox也可以通过FoxyProxy插件进行解决。而IE么，就很麻烦了，有人建议用polipo或者是privoxy将socks代理转成http代理，所以比较恶心……

其他一些翻墙利器推荐:

Power.com 在线代理翻墙工具    官方网站：http://www.power.com
Fanqiang.org 超强匿名在线代理服务器，翻墙利器
官方网站:http://fanqiang.org/

Puff the magic dragon，简称 Puff，一款专业小巧实用的翻墙工具。
官方主页：http://www.erights.net（已被河蟹）
UseJump 无需任何设置即可翻墙的浏览器，个人感觉速度比TOR快，据说是对链接进行过优化。
官方网站http://beta.usejump.com/
Tags - , , , ]]> http://zhoujin.com/post/136/ <![CDATA[市场热点100426]]> chirs <> Mon, 26 Apr 2010 01:27:08 +0000 http://zhoujin.com/post/136/ Tags - , , , ]]> http://zhoujin.com/post/135/ <![CDATA[股指期货100415]]> chirs <> Thu, 15 Apr 2010 00:24:20 +0000 http://zhoujin.com/post/135/ Tags - ]]> http://zhoujin.com/post/141/ <![CDATA[原来是人祸]]> chirs <> Sat, 10 Apr 2010 07:10:36 +0000 http://zhoujin.com/post/141/ 这里和这里，读到了如下信息：
引用
西南干旱后，很多人认为，是由于下雨少所致，也即天灾所致。但是，查一下新闻后，发现类似的“天灾”一直在上演（仅以云南的新闻为例）：2004年，我国南方“遭受53年来罕见干旱”，云南在干旱之列；2005年，云南“遭遇近50年来最大干旱”；2006年，“云南遭遇20年来最严重旱情”；2007年，“云南大部地区降水不足，气温偏高，旱情日趋严重”；“2008年云南连续近三个月干旱”；2009年，“云南省遭遇五十年一遇的严重旱情”；2010年，云南“秋冬春连旱”百年一遇……

我实地调查得出的结果是：西南干旱，一分天灾，九分人祸。

点击在新窗口中浏览此图片

如此险地都被用作农田
点击在新窗口中浏览此图片


所谓的高经济作物桉树，让物种变得单一，成为绿色的沙漠：雨水来了泥土流失，大旱来了与其他植物抢水。

一旦金钱成为从上至下追求的目标，那么什么都变了。由于在认知上的局限性，当时空上因果关系看不到连续性的时候，人索性放弃了任何信仰。60年代建立的水库设施，在改革开放近30年的时间里，就不记得修葺，以至于雨季存不下水，旱季没有水；片面的认为绿化就是种树，将侵略性极强的桉树大面积栽种，所到之处，除了桉树草木不生，动物也不来，彻底破坏生态平衡；一旦没有水，没有想办法解决集水的问题就到处打井寻找地下水，导致地下水位下降，进一步造成不可预知的影响；“先污染、再治理”带来的是花10亿去污染，然后花10倍以上的代价去治理；为了城市供水，农业和农民一起被边缘化，为了GDP, 大量的炸山开矿填海围田……

一些悲剧正在上演：情人湖上的别墅听起来如同烹食天鹅肉一样让人悲愤；沙漠上好不容易防风固沙的沙棘生态林被弄成高尔夫；还有一些扑朔迷离的东湖填湖事件，就发生在我的家乡武汉——我不敢想象，失去东湖的武汉人，会愤怒悲伤到何种程度……

这些，我们又能做些什么呢？为什么生活越现代，信仰就越匮乏？《阿凡达》中潘多拉星球上的惨胜，或许只是导演一厢情愿的美好愿望——真实情况也许是，世界之树被连根拔起，所有的树木被砍倒，地面铺上水泥和柏油，大量的超导矿石被拉走——或者留下几棵树，作为观光景点，建立一片别墅群……在最终资源毫无利用价值之后，这颗星球被毫不留情的废弃，成为宇宙中的垃圾……
Tags - , , ]]> http://zhoujin.com/post/140/ <![CDATA[不信任的博弈]]> chirs <> Thu, 01 Apr 2010 07:08:34 +0000 http://zhoujin.com/post/140/
说的是十年前的事情。

然而现在英雄越见少了——英雄们逐渐淡出一线开发视野。现在动辄几十人上百人的团队下，英雄的候选们发现他们处于一个相当悲凉的境地：即便有心救国，看着若干年积累出来的代码；或者正在积累中的代码，充满着无力的挫败感。我依然记得在某个项目中，只有20人左右的团队，当发现架构存在问题的时候，却也无法做什么：交付的压力持续不断的增加着，新的方式需要进行花时间验证才能得到证明，于是一方面团队按照旧的方式将代码往上堆，另一方面对此感到痛苦的不断地修改着——这个循环直到项目结束才算真正意义上的结束。

业务团队与开发团队之间的不信任感从此而产生——

为什么这么简单的一个功能要这么久？
不行，这个功能一定要在某月某日之前出来！
做不出来，丢了这个客户/市场，你负责吗？！

于是，迫于这种压力，开发团队只好采用更加临时的解决方案来快速解决问题——寄希望于某一天能够有时间把这些问题神奇般的解决——可是这一天从来都没有到来过。一个交付周期过去了，下一个接踵而至，带来更大的挑战——“什么？需要时间重构？没时间啦！这个客户比上一个更重要，一定要做出来啊！”

听到一个很形象的例子。一只蚂蚁只能拉100斤的东西。由于要交付更多的东西，蚂蚁工头对小蚂蚁说，120斤，挑战一下吧。小蚂蚁咬咬牙，挑战了一下。这一下真挑战成功了——120斤成功的拉过去了！然而它自己觉得隐隐作痛——受内伤了，它想歇息一段时间，可是工头说：不错，120斤挑战成功了，这一次我们有更大的挑战，150斤，努力吧！

临时的方案往往带来更多的缺陷。我听说过一些团队为了快速解决某一个问题写了100行的SQL代码——这些SQL代码成为后续维护的噩梦。业务团队发现了这些：虽然这些版本通过加班、通宵能够某种程度上如期交付，但是交付出来质量问题太多——不可接受。但同时要求质量和进度看起来是那么的不可行，于是，为了控制风险，好吧，以后做计划的时候给自己留下余量——不信任的博弈由此开始：

用户说，这个功能我要在2010年10月1日完成。
市场/用户服务部门想了想，说，对开发部门的领导说，这个版本必须在2010年9月10日完成。
开发部门领导想了想，对开发团队说，这个需求非常紧急，这样吧，8月15必须如期交付，否则我们就丢掉了这个客户！

一来二往，双方都清楚了这个游戏规则。然而作为生态链的最底端，开发团队做不了什么——既然整个博弈决定了进度第一，那么质量只好放在那些余量里面了。“先污染，再治理”，所有的临时解决方案被使用——配置文件满天飞，SQL随便写，各式的hack写法，等等等等。到了后期交付的时候，测试问题多多，改吧，加班、通宵改吧。

如果质量不是贯穿在开发过程中，那么通过最终的质检环节来提升质量无疑是低效的。Deming说，”Build Quality in”. 质量是隐含的。形成这个博弈的最大的原因是，从前到后对交付的轻视，对质量的轻视，对于软件演进必要的理解。进度必然是符合质量的功能点的交付，而不是狭隘的代码完成。
Tags - , , ]]> http://zhoujin.com/post/139/ <![CDATA[Google Notifiers for Mac]]> chirs <> Fri, 26 Mar 2010 06:56:44 +0000 http://zhoujin.com/post/139/
Picasa这类软件对我而言不是日常必需品，相对而言，我特别喜欢“Google Notifiers for Mac”，它是一款简单又实用的软件，用于提醒日历和Gmail。

没有什么花俏的东西，仅仅是常驻系统通知区域，然后通过Growl这个通知区域的工具来提醒即将到来的任务或邮件。比如：
点击在新窗口中浏览此图片
点击详情，可以进行大部分操作，当然都会重定向至Web界面。很方便快捷。

很普通的的一款软件吧。Linux下对我而言还缺少一款小巧的能提醒日历的工具，Docky上的Gmail提醒已经能满足我的需求了。

当然，未来这些都可能由Chrome的插件来搞定，只是桌面通知机制似乎还不成熟。
Tags - , , ]]> http://zhoujin.com/post/138/ <![CDATA[谷歌的搬家]]> chirs <> Tue, 23 Mar 2010 06:53:36 +0000 http://zhoujin.com/post/138/
对我本人而言，如果不看新闻，我是不会知道的。因为从去年2月开始，我就已经是全日制VPN用户了。

因此我一直在设想，假如我是一个普通的谷歌粉，会对这次搬家有些什么想法呢？

我很难想像，而且也猜测不到未来后续事项的发展，因为功夫网经常会出人意料地做出一些常人不能理解的事情。

与其废尽心思去想，不如照旧做自己该做的事情。更何况谷歌现在只是搬家而已，没有被完全挡住嘛。

其他也没什么好说的了.
Tags - ]]> http://zhoujin.com/post/137/ <![CDATA[Mac五笔输入首选：万寿果五笔输入法]]> chirs <> Sun, 14 Feb 2010 06:42:38 +0000 http://zhoujin.com/post/137/
当一些用惯电脑的人们都不知道汉字怎么写的时候，我还能把一些“繁體字”都能写出来。这是因为用五笔的人，一般会输则意味着会写。至少我就是这样。

但是五笔用户还有一个囧境，一般某个公司出针对某个平台的输入法时，都会先出拼音，然后再出五笔（或者选择不出）。没办法，五笔的用户少啊～

特别是至今为止，Android平台上还没有一款令人满意的五笔输入法，这让我有时真的有冲动去写一款，但是不可能啦。

然而这个时候，却有一家异类，竟然将五笔输入法做为其主打产品，它就是：万寿果软件，出了款for Mac的五笔输入法。

网站主页是这里：http://www.pawpawsoft.com/，因为该输入法不仅相当好用，而且完全免费，所以今天才花时间介绍一下，推荐给少之又少的五笔兼Mac用户。
之前我在Mac下用的是FIT输入法，同时支持拼音和五笔，总觉得有点不适。在Ubuntu下，我用的是ibus-table-wubi，总体来说还算不错！

但是用了万果寿五笔输入法，才让我感觉到，这才是一款真正用心为五笔用户设计的输入法。

废话不多讲，开始截图：

首先是普通模式，嗯，正常的五笔输入法都应该是这样。
点击在新窗口中浏览此图片

但是它又有创新的“临时拼音”模式，按“`”即可进入
点击在新窗口中浏览此图片

更创新的是，临时拼音打出来的词，还会附上五笔反查编码！这个太棒了！这意味着，碰到不会打的字，我不仅能很快打出来，而且能顺便将其学会！

（奇怪，我要打的“shabi”怎么没出来？）
点击在新窗口中浏览此图片

嗯，临时英文模式也是相当不错的。大写一个字母，就OK了。
点击在新窗口中浏览此图片

还有很多特性，特别是定制能力超强，请看：
点击在新窗口中浏览此图片

真是一款又强大又低调的五笔输入法！

万寿果这家专门开发Mac软件的公司也蛮有意思，持续关注中⋯⋯
Tags - ]]> http://zhoujin.com/post/146/ <![CDATA[Servlet 3.0 新特性详解]]> chirs <> Mon, 25 Jan 2010 02:47:21 +0000 http://zhoujin.com/post/146/
Servlet 3.0 作为 Java EE 6 规范体系中一员，随着 Java EE 6 规范一起发布。该版本在前一版本（Servlet 2.5）的基础上提供了若干新特性用于简化 Web 应用的开发和部署。其中有几项特性的引入让开发者感到非常兴奋，同时也获得了 Java 社区的一片赞誉之声：

异步处理支持：有了该特性，Servlet 线程不再需要一直阻塞，直到业务处理完毕才能再输出响应，最后才结束该 Servlet 线程。在接收到请求之后，Servlet 线程可以将耗时的操作委派给另一个线程来完成，自己在不生成响应的情况下返回至容器。针对业务处理较耗时的情况，这将大大减少服务器资源的占用，并且提高 并发处理速度。
新增的注解支持：该版本新增了若干注解，用于简化 Servlet、过滤器（Filter）和监听器（Listener）的声明，这使得 web.xml 部署描述文件从该版本开始不再是必选的了。
可插性支持：熟悉 Struts2 的开发者一定会对其通过插件的方式与包括 Spring 在内的各种常用框架的整合特性记忆犹新。将相应的插件封装成 JAR 包并放在类路径下，Struts2 运行时便能自动加载这些插件。现在 Servlet 3.0 提供了类似的特性，开发者可以通过插件的方式很方便的扩充已有 Web 应用的功能，而不需要修改原有的应用。
下面我们将逐一讲解这些新特性，通过下面的学习，读者将能够明晰了解 Servlet 3.0 的变化，并能够顺利使用它进行日常的开发工作。

Servlet 3.0 之前，一个普通 Servlet 的主要工作流程大致如下：首先，Servlet 接收到请求之后，可能需要对请求携带的数据进行一些预处理；接着，调用业务接口的某些方法，以完成业务处理；最后，根据处理的结果提交响 应，Servlet 线程结束。其中第二步的业务处理通常是最耗时的，这主要体现在数据库操作，以及其它的跨网络调用等，在此过程中，Servlet 线程一直处于阻塞状态，直到业务方法执行完毕。在处理业务的过程中，Servlet 资源一直被占用而得不到释放，对于并发较大的应用，这有可能造成性能的瓶颈。对此，在以前通常是采用私有解决方案来提前结束 Servlet 线程，并及时释放资源。

Servlet 3.0 针对这个问题做了开创性的工作，现在通过使用 Servlet 3.0 的异步处理支持，之前的 Servlet 处理流程可以调整为如下的过程：首先，Servlet 接收到请求之后，可能首先需要对请求携带的数据进行一些预处理；接着，Servlet 线程将请求转交给一个异步线程来执行业务处理，线程本身返回至容器，此时 Servlet 还没有生成响应数据，异步线程处理完业务以后，可以直接生成响应数据（异步线程拥有 ServletRequest 和 ServletResponse 对象的引用），或者将请求继续转发给其它 Servlet。如此一来， Servlet 线程不再是一直处于阻塞状态以等待业务逻辑的处理，而是启动异步线程之后可以立即返回。

异步处理特性可以应用于 Servlet 和过滤器两种组件，由于异步处理的工作模式和普通工作模式在实现上有着本质的区别，因此默认情况下，Servlet 和过滤器并没有开启异步处理特性，如果希望使用该特性，则必须按照如下的方式启用：
1.对于使用传统的部署描述文件 (web.xml) 配置 Servlet 和过滤器的情况，Servlet 3.0 为 和 标签增加了 子标签，该标签的默认取值为 false，要启用异步处理支持，则将其设为 true 即可。以 Servlet 为例，其配置方式如下所示：
<servlet>
    <servlet-name>DemoServlet</servlet-name>
    <servlet-class>footmark.servlet.Demo Servlet</servlet-class>
    <async-supported>true</async-supported>
</servlet>

2.对于使用 Servlet 3.0 提供的 @WebServlet 和 @WebFilter 进行 Servlet 或过滤器配置的情况，这两个注解都提供了 asyncSupported 属性，默认该属性的取值为 false，要启用异步处理支持，只需将该属性设置为 true 即可。以 @WebFilter 为例，其配置方式如下所示：
@WebFilter(urlPatterns = "/demo",asyncSupported = true)
public class DemoFilter implements Filter{...}

  一个简单的模拟异步处理的 Servlet 示例如下：
@WebServlet(urlPatterns = "/demo", asyncSupported = true)
public class AsyncDemoServlet extends HttpServlet {
    @Override
    public void doGet(HttpServletRequest req, HttpServletResponse resp)
    throws IOException, ServletException {
        resp.setContentType("text/html;charset=UTF-8");
        PrintWriter out = resp.getWriter();
        out.println("进入Servlet的时间：" + new Date() + ".");
        out.flush();

        //在子线程中执行业务调用，并由其负责输出响应，主线程退出
        AsyncContext ctx = req.startAsync();
        new Thread(new Executor(ctx)).start();

        out.println("结束Servlet的时间：" + new Date() + ".");
        out.flush();
    }
}

public class Executor implements Runnable {
    private AsyncContext ctx = null;
    public Executor(AsyncContext ctx){
        this.ctx = ctx;
    }

    public void run(){
        try {
            //等待十秒钟，以模拟业务方法的执行
            Thread.sleep(10000);
            PrintWriter out = ctx.getResponse().getWriter();
            out.println("业务处理完毕的时间：" + new Date() + ".");
            out.flush();
            ctx.complete();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

除此之外，Servlet 3.0 还为异步处理提供了一个监听器，使用 AsyncListener 接口表示。它可以监控如下四种事件：
1.异步线程开始时，调用 AsyncListener 的 onStartAsync(AsyncEvent event) 方法；
2.异步线程出错时，调用 AsyncListener 的 onError(AsyncEvent event) 方法；
3.异步线程执行超时，则调用 AsyncListener 的 onTimeout(AsyncEvent event) 方法；
4.异步执行完毕时，调用 AsyncListener 的 onComplete(AsyncEvent event) 方法；

要注册一个 AsyncListener，只需将准备好的 AsyncListener 对象传递给 AsyncContext 对象的 addListener() 方法即可，如下所示：
AsyncContext ctx = req.startAsync();
ctx.addListener(new AsyncListener() {
    public void onComplete(AsyncEvent asyncEvent) throws IOException {
        // 做一些清理工作或者其他
    }
    ...
});

Servlet 3.0 的部署描述文件 web.xml 的顶层标签 有一个 metadata-complete 属性，该属性指定当前的部署描述文件是否是完全的。如果设置为 true，则容器在部署时将只依赖部署描述文件，忽略所有的注解（同时也会跳过 web-fragment.xml 的扫描，亦即禁用可插性支持，具体请看后文关于 可 插性支持的讲解）；如果不配置该属性，或者将其设置为 false，则表示启用注解支持（和可插性支持）。

@WebServlet

@WebServlet 用于将一个类声明为 Servlet，该注解将会在部署时被容器处理，容器将根据具体的属性配置将相应的类部署为 Servlet。该注解具有下表给出的一些常用属性（以下所有属性均为可选属性，但是 vlaue 或者 urlPatterns 通常是必需的，且二者不能共存，如果同时指定，通常是忽略 value 的取值）：
表 1. @WebServlet 主要属性列表

属性名                 类型                  描述
name                 String               指定 Servlet 的 name 属性，等价于 。如果没有显式指定，则该 Servlet 的取值即为类的全限定名。
value                 String[]             该属性等价于 urlPatterns 属性。两个属性不能同时使用。
urlPatterns         String[]             指定一组 Servlet 的 URL 匹配模式。等价于 标签。
loadOnStartup    int                    指 定 Servlet 的加载顺序，等价于 标签。
initParams          WebInitParam[]  指定一组 Servlet 初始化参数，等价于 标签。
asyncSupported  boolean             声 明 Servlet 是否支持异步操作模式，等价于 标签。
description         String                该 Servlet 的描述信息，等价于 标签。
displayName       String                该 Servlet 的显示名，通常配合工具使用，等价于 标签。


下面是一个简单的示例：
@WebServlet(urlPatterns = {"/simple"}, asyncSupported = true,
loadOnStartup = -1, name = "SimpleServlet", displayName = "ss",
initParams = {@WebInitParam(name = "username", value = "tom")}
)
public class SimpleServlet extends HttpServlet{ … }


如此配置之后，就可以不必在 web.xml 中配置相应的 和 元素了，容器会在部署时根据指定的属性将该类发布为 Servlet。它的等价的 web.xml 配置形式如下：
<servlet>
    <display-name>ss</display-name>
    <servlet-name>SimpleServlet</servlet-name>
    <servlet-class>footmark.servlet.SimpleServlet</servlet-class>
    <load-on-startup>-1</load-on-startup>
    <async-supported>true</async-supported>
    <init-param>
        <param-name>username</param-name>
        <param-value>tom</param-value>
    </init-param>
</servlet>
<servlet-mapping>
    <servlet-name>SimpleServlet</servlet-name>
    <url-pattern>/simple</url-pattern>
</servlet-mapping>


@WebInitParam

该注解通常不单独使用，而是配合 @WebServlet 或者 @WebFilter 使用。它的作用是为 Servlet 或者过滤器指定初始化参数，这等价于 web.xml 中 和 的 子标签。@WebInitParam 具有下表给出的一些常用属性：

@WebInitParam

该注解通常不单独使用，而是配合 @WebServlet 或者 @WebFilter 使用。它的作用是为 Servlet 或者过滤器指定初始化参数，这等价于 web.xml 中 和 的 子标签。@WebInitParam 具有下表给出的一些常用属性：


表 2. @WebInitParam 的常用属性

属性名        类型  是否可选          描述
name          String   否         指定参数的名字，等 价于 。
value           String  否         指 定参数的值，等价于 。
description   String  是         关于参数的描述，等价于 。


@WebFilter

@WebFilter 用于将一个类声明为过滤器，该注解将会在部署时被容器处理，容器将根据具体的属性配置将相应的类部署为过滤器。该注解具有下表给出的一些常用属性 ( 以下所有属性均为可选属性，但是 value、urlPatterns、servletNames 三者必需至少包含一个，且 value 和 urlPatterns 不能共存，如果同时指定，通常忽略 value 的取值 )：


表 3. @WebFilter 的常用属性

属性名                类型                                    描述
filterName          String                指定过滤器的 name 属性，等价于
value                 String[]             该属性等价于 urlPatterns 属性。但是两者不应该同时使用。
urlPatterns         String[]             指定一组过滤器的 URL 匹配模式。等价于 标签。
servletNames      String[]             指定过滤器将应用于哪些 Servlet。取值是 @WebServlet 中的 name 属性的取值，或者是 web.xml 中 的取值。
dispatcherTypes  DispatcherType  指定过滤器的转发模式。具体取值包括：ASYNC、ERROR、 FORWARD、INCLUDE、REQUEST。
initParams          WebInitParam[]   指定一组过滤器初始化参数，等价于 标签。
asyncSupported  boolean              声明过滤器是否支持异步操作模式，等价于 标签。
description         String                 该过滤器的描述信息，等价于 标签。
displayName       String                 该过滤器的显示名，通常配合工具使用，等价于 标签。

下面是一个简单的示例：
@WebFilter(servletNames = {"SimpleServlet"},filterName="SimpleFilter")
public class LessThanSixFilter implements Filter{...}

如此配置之后，就可以不必在 web.xml 中配置相应的 和 元素了，容器会在部署时根据指定的属性将该类发布为过滤器。它等价的 web.xml 中的配置形式为：
<filter>
    <filter-name>SimpleFilter</filter-name>
    <filter-class>xxx</filter-class>
</filter>
<filter-mapping>
    <filter-name>SimpleFilter</filter-name>
    <servlet-name>SimpleServlet</servlet-name>
</filter-mapping>


@WebListener

该注解用于将类声明为监听器，被 @WebListener 标注的类必须实现以下至少一个接口：

ServletContextListener
ServletContextAttributeListener
ServletRequestListener
ServletRequestAttributeListener
HttpSessionListener
HttpSessionAttributeListener
该注解使用非常简单，其属性如下：


表 4. @WebListener 的常用属性

属性名  类型       是否可选  描述
value          String  是          该监听器的描述信 息。


一个简单示例如下：
@WebListener("This is only a demo listener")
public class SimpleListener implements ServletContextListener{...}

如此，则不需要在 web.xml 中配置 标签了。它等价的 web.xml 中的配置形式如下：
<listener>
    <listener-class>footmark.servlet.SimpleListener</listener-class>
</listener>

@MultipartConfig

该注解主要是为了辅助 Servlet 3.0 中 HttpServletRequest 提供的对上传文件的支持。该注解标注在 Servlet 上面，以表示该 Servlet 希望处理的请求的 MIME 类型是 multipart/form-data。另外，它还提供了若干属性用于简化对上传文件的处理。具体如下：


表 5. @MultipartConfig 的常用属性

属性名          类型   是否可选     描述
fileSizeThreshold  int     是          当数据量大于该值时，内容将被写入文件。
location          String   是          存放生成的文件地址。
maxFileSize          long     是          允许上传的文件最大值。默认值为 -1，表示没有限制。
maxRequestSize  long     是          针对该 multipart/form-data 请求的最大数量，默认值为 -1，表示没有限制。

如果说 3.0 版本新增的注解支持是为了简化 Servlet/ 过滤器 / 监听器的声明，从而使得 web.xml 变为可选配置， 那么新增的可插性 (pluggability) 支持则将 Servlet 配置的灵活性提升到了新的高度。熟悉 Struts2 的开发者都知道，Struts2 通过插件的形式提供了对包括 Spring 在内的各种开发框架的支持，开发者甚至可以自己为 Struts2 开发插件，而 Servlet 的可插性支持正是基于这样的理念而产生的。使用该特性，现在我们可以在不修改已有 Web 应用的前提下，只需将按照一定格式打成的 JAR 包放到 WEB-INF/lib 目录下，即可实现新功能的扩充，不需要额外的配置。

Servlet 3.0 引入了称之为“Web 模块部署描述符片段”的 web-fragment.xml 部署描述文件，该文件必须存放在 JAR 文件的 META-INF 目录下，该部署描述文件可以包含一切可以在 web.xml 中定义的内容。JAR 包通常放在 WEB-INF/lib 目录下，除此之外，所有该模块使用的资源，包括 class 文件、配置文件等，只需要能够被容器的类加载器链加载的路径上，比如 classes 目录等。

现在，为一个 Web 应用增加一个 Servlet 配置有如下三种方式 ( 过滤器、监听器与 Servlet 三者的配置都是等价的，故在此以 Servlet 配置为例进行讲述，过滤器和监听器具有与之非常类似的特性 )：
1.编写一个类继承自 HttpServlet，将该类放在 classes 目录下的对应包结构中，修改 web.xml，在其中增加一个 Servlet 声明。这是最原始的方式；
2.编写一个类继承自 HttpServlet，并且在该类上使用 @WebServlet 注解将该类声明为 Servlet，将该类放在 classes 目录下的对应包结构中，无需修改 web.xml 文件。
3.编写一个类继承自 HttpServlet，将该类打成 JAR 包，并且在 JAR 包的 META-INF 目录下放置一个 web-fragment.xml 文件，该文件中声明了相应的 Servlet 配置。web-fragment.xml 文件示例如下：
<?xml version="1.0" encoding="UTF-8"?>
<web-fragment
    xmlns=http://java.sun.com/xml/ns/javaee
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="3.0"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
    http://java.sun.com/xml/ns/javaee/web-fragment_3_0.xsd"
    metadata-complete="true">
    <servlet>
        <servlet-name>fragment</servlet-name>
        <servlet-class>footmark.servlet.FragmentServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>fragment</servlet-name>
        <url-pattern>/fragment</url-pattern>
    </servlet-mapping>
</web-fragment>

从上面的示例可以看出，web-fragment.xml 与 web.xml 除了在头部声明的 XSD 引用不同之外，其主体配置与 web.xml 是完全一致的。

由于一个 Web 应用中可以出现多个 web-fragment.xml 声明文件，加上一个 web.xml 文件，加载顺序问题便成了不得不面对的问题。Servlet 规范的专家组在设计的时候已经考虑到了这个问题，并定义了加载顺序的规则。

web-fragment.xml 包含了两个可选的顶层标签， 和 ，如果希望为当前的文件指定明确的加载顺序，通常需要使用这两个标签， 主要用于标识当前的文件，而 则用于指定先后顺序。一个简单的示例如下：
<web-fragment...>
    <name>FragmentA</name>
    <ordering>
        <after>
            <name>FragmentB</name>
            <name>FragmentC</name>
        </after>
    <before>
        <others/>
    </before>
    </ordering>
    ...
</web-fragment>

如上所示， 标签的取值通常是被其它 web-fragment.xml 文件在定义先后顺序时引用的，在当前文件中一般用不着，它起着标识当前文件的作用。

在 标签内部，我们可以定义当前 web-fragment.xml 文件与其他文件的相对位置关系，这主要通过 的 和 子标签来实现的。在这两个子标签内部可以通过 标签来指定相对应的文件。比如：
<after>
    <name>FragmentB</name>
    <name>FragmentC</name>
</after>

以上片段则表示当前文件必须在 FragmentB 和 FragmentC 之后解析。 的使用于此相同，它所表示的是当前文件必须早于 标签里所列出的 web-fragment.xml 文件。

除了将所比较的文件通过 在 和 中列出之外，Servlet 还提供了一个简化的标签 。它表示除了当前文件之外的其他所有的 web-fragment.xml 文件。该标签的优先级要低于使用 明确指定的相对位置关系。

除了以上的新特性之外，ServletContext 对象的功能在新版本中也得到了增强。现在，该对象支持在运行时动态部署 Servlet、过滤器、监听器，以及为 Servlet 和过滤器增加 URL 映射等。以 Servlet 为例，过滤器与监听器与之类似。ServletContext 为动态配置 Servlet 增加了如下方法：
1.ServletRegistration.Dynamic addServlet(String servletName,Class servletClass)
2.ServletRegistration.Dynamic addServlet(String servletName, Servlet servlet)
3.ServletRegistration.Dynamic addServlet(String servletName, String className)
4. T createServlet(Class clazz)
5.ServletRegistration getServletRegistration(String servletName)
6.Map getServletRegistrations()
其中前三个方法的作用是相同的，只是参数类型不同而已；通过 createServlet() 方法创建的 Servlet，通常需要做一些自定义的配置，然后使用 addServlet() 方法来将其动态注册为一个可以用于服务的 Servlet。两个 getServletRegistration() 方法主要用于动态为 Servlet 增加映射信息，这等价于在 web.xml( 抑或 web-fragment.xml) 中使用 标签为存在的 Servlet 增加映射信息。

以上 ServletContext 新增的方法要么是在 ServletContextListener 的 contexInitialized 方法中调用，要么是在 ServletContainerInitializer 的 onStartup() 方法中调用。

ServletContainerInitializer 也是 Servlet 3.0 新增的一个接口，容器在启动时使用 JAR 服务 API(JAR Service API) 来发现 ServletContainerInitializer 的实现类，并且容器将 WEB-INF/lib 目录下 JAR 包中的类都交给该类的 onStartup() 方法处理，我们通常需要在该实现类上使用 @HandlesTypes 注解来指定希望被处理的类，过滤掉不希望给 onStartup() 处理的类。

HttpServletRequest 对文件上传的支持

此前，对于处理上传文件的操作一直是让开发者头疼的问题，因为 Servlet 本身没有对此提供直接的支持，需要使用第三方框架来实现，而且使用起来也不够简单。如今这都成为了历史，Servlet 3.0 已经提供了这个功能，而且使用也非常简单。为此，HttpServletRequest 提供了两个方法用于从请求中解析出上传的文件：
1.Part getPart(String name)
2.Collection getParts()

前者用于获取请求中给定 name 的文件，后者用于获取所有的文件。每一个文件用一个 javax.servlet.http.Part 对象来表示。该接口提供了处理文件的简易方法，比如 write()、delete() 等。至此，结合 HttpServletRequest 和 Part 来保存上传的文件变得非常简单，如下所示：

Part photo = request.getPart("photo");
photo.write("/tmp/photo.jpg"); // 可以将两行代码简化为 request.getPart("photo").write("/tmp/photo.jpg") 一行。


另外，开发者可以配合前面提到的 @MultipartConfig 注解来对上传操作进行一些自定义的配置，比如限制上传文件的大小，以及保存文件的路径等。其用法非常简单，故不在此赘述了。

需要注意的是，如果请求的 MIME 类型不是 multipart/form-data，则不能使用上面的两个方法，否则将抛异常。

Servlet 3.0 的众多新特性使得 Servlet 开发变得更加简单，尤其是异步处理特性和可插性支持的出现，必将对现有的 MVC 框架产生深远影响。虽然我们通常不会自己去用 Servlet 编写控制层代码，但是也许在下一个版本的 Struts 中，您就能切实感受到这些新特性带来的实质性改变。
Tags - , , , ]]> http://zhoujin.com/post/134/ <![CDATA[七个小细节毁掉你的身体]]> chirs <> Fri, 01 Jan 2010 00:47:26 +0000 http://zhoujin.com/post/134/ 　　饿了才吃：
　　生活中许多人不是按时就餐，且有相当一部分人不吃早餐，其理由之一就是“不饿”。其实，食物在胃内仅停留4－5小时，感到饥饿时胃早已排空。胃黏膜这时会被胃液“自我消化”，引起胃炎或消化性溃疡。饮食规律、营养均衡是养生保健必不可少的物质基础。
　　渴了才喝：
　　平时不喝水、口渴时才饮水的人相当多，尤其是青少年和“大忙人”。他们不了解渴了是体内缺水的反应，这时再补充水分为时已晚。水对人体代谢比食物还重要，生理学家告诉我们，每个成年人每天需饮水1500毫升左右。晨间或餐前一小时喝一杯水大有益处，既可洗涤胃肠，又有助于消化，促进食欲。据调查研究，有经常饮水习惯的人，便秘、尿路结石的患病率明显低于不常饮水的人。
　　累了才歇：
　　许多人误以为累了是应该休息的信号，其实是身体相当疲劳的“自我感觉”，这时才休息已为时过晚。过度疲劳容易积劳成疾，降低人体免疫力，使疾病乘虚而入。不论是脑力还是体力劳动者，在连续工作一段时间后，都要适当的休息或调整。
　　困了才睡：
　　困倦是大脑相当疲劳的表现，不应该等到这时才去睡觉。按时就寝不仅可以保护大脑，还能提高睡眠质量，减少失眠。人的一生约有1/3时间是在睡眠中度过的，睡眠是新陈代谢活动中重要的生理过程。只有养成定时睡觉的习惯，保证每天睡眠时间不少于7小时，才能维持睡眠中枢生物钟的正常运转。
　　急了才排：
　　很多人只在便意明显时才去厕所，甚至有便不解，宁愿憋着，这样对健康极为不利。大小便在体内停留过久，容易引起便秘或膀胱过度充盈，粪便和尿液内的有毒物质被人体重吸收，可导致“自身中毒”。因此，应养成按时排便的习惯，尤以晨间为好，以减少痔疮、便秘、大肠癌的发病机会。
　　胖了才减：
　　随着生活水平的提高，肥胖患者日逐增加。导致肥胖的原因主要是进食过量，营养过剩，缺乏运动。而这几种诱因完全可以在体重超标之前加以预防，如控制饮食，防止暴饮暴食，调整饮食，加强体育锻炼。目前市场上还没有理想的减肥药，因此，减肥不如防止肥胖。
　　病了才治
　　疾病应该以防为主，等疾病上身，已经对身体造成危害。疾病到来时都是有信号的，比如人们常说的亚健康状态就是疾病的前奏。平时应该加强锻炼，提高自身抵御疾病的能力，感到身体的亚健康，就要引起注意，要把疾病消灭在萌芽状态。
Tags - ]]> http://zhoujin.com/post/132/ <![CDATA[600597光明乳业]]> chirs <> Fri, 11 Dec 2009 01:48:36 +0000 http://zhoujin.com/post/132/ Tags - ]]> http://zhoujin.com/post/131/ <![CDATA[《2012》启示了什么？]]> chirs <> Thu, 19 Nov 2009 07:53:50 +0000 http://zhoujin.com/post/131/ 2.别轻视一个突然出现在宴会上不穿礼服的小伙，他可能是带着一个足够影响世界安危的消息。
3.别轻视一个志向的疯子，真理一般都掌握在疯子手中，要时刻留心疯子的言论，他们的话要比某些专家教授权威的多也准确的多。
4.即使你买买不起飞机也要去学开飞机，真到了世界末日你不会，会很郁闷的。
5.如果女友跟你结婚要你买房，而且是说着没有房子没有安全感这种理由，你可以花128元买两张电影票和一桶爆米花和她一起看《2012》，然后成功打消她的观点。
6.救命的“票”可能一分不取，可能要十亿欧元。
7.世界上父爱的伟大是一样的，不管你是总统、富商、还是普通人。为了儿女，他们可以放弃一切甚至生命。
8.关键时刻相信中国，相信“Made in China”，否则世界各国也不会把造“方舟”的地点选在中国。
9.中国完全有能力造出及其坚固的航空母舰，而且它比美国航母更强，美国航母在总统面前“粉身碎骨”，中国航母也许还能在世界末日拯救几万人。
10.千万不要在网上看盗版的电影，尤其是看这种音响效果很重要的灾难片，一个从电影院里面偷录出来的电影会让你耳朵先到达世界末日。
Tags - , , ]]> http://zhoujin.com/post/133/ <![CDATA[Tomcat内存溢出的三种情况及解决办法分析]]> chirs <> Sun, 15 Nov 2009 02:42:35 +0000 http://zhoujin.com/post/133/     在生产环境中tomcat内存设置不好很容易出现内存溢出。造成内存原因是不一样的，当然处理方式也不一样。

    这里根据平时遇到的情况和相关资料进行一个总结。常见的一般会有下面三种情况：

    1.OutOfMemoryError： Java heap space

    2.OutOfMemoryError： PermGen space

    3.OutOfMemoryError： unable to create new native thread.

    Tomcat内存溢出解决方案：

    对于前两种情况，在应用本身没有内存泄露的情况下可以用设置tomcat jvm参数来解决。（-Xms -Xmx -XX：PermSize  -XX：MaxPermSize）

    最后一种可能需要调整操作系统和tomcat jvm参数同时调整才能达到目的。

    第一种：是堆溢出。

    在JVM中如果98％的时间是用于GC且可用的 Heap size 不足2％的时候将抛出此异常信息。

    没有内存泄露的情况下，调整-Xms -Xmx参数可以解决。

    -Xms：初始堆大小

    -Xmx：最大堆大小

    但堆的大小受下面三方面影响：

    1.相关操作系统的数据模型（32-bt还是64-bit）限制；（32位系统下，一般限制在1.5G~2G；我在2003 server 系统下（物理内存：4G和6G，jdk：1.6）测试 1612M，64为操作系统对内存无限制。）

    2.系统的可用虚拟内存限制；

    3.系统的可用物理内存限制。

    堆的大小可以使用 java -Xmx***M  version 命令来测试。支持的话会出现jdk的版本号，不支持会报错。

    -Xms -Xmx一般配置成一样比较好比如set JAVA_OPTS= -Xms1024m -Xmx1024m

    第二种：永久保存区域溢出

    PermGen space的全称是Permanent Generation space，是指内存的永久保存区域。这一部分用于存放Class和Meta的信息，Class在被 Load的时候被放入PermGen space区域，它和和存放Instance的Heap区域不同，GC（Garbage Collection）不会在主程序运行期对PermGen space进行清理，所以如果你的APP会LOAD很多CLASS的话，就很可能出现PermGen space错误。这种错误常见在web服务器对JSP进行pre compile的时候。但目前的hibernate和spring项目中也很容易出现这样的问题。(http://www.javaeye.com/topic/80620?page=1) 的帖子有讨论的这个问题。可能是由于这些框架会动态class，而且jvm的gc是不会清理PemGen space的，导致内存溢出。

    这一个一般是加大-XX：PermSize  -XX：MaxPermSize 来解决问题。

    -XX：PermSize 永久保存区域初始大小

    -XX：PermSize 永久保存区域初始最大值

    这一般结合第一条使用，比如 set JAVA_OPTS= -Xms1024m -Xmx1024m  -XX：PermSize=128M -XX：PermSize=256M

    有一点需要注意：java -Xmx***M  version 命令来测试的最大堆内存是 -Xmx与 -XX：PermSize的 和 比如系统支持最大的jvm堆大小事1.5G，那  -Xmx1024m  -XX：PermSize=768M 是无法运行的。

    第三种：无法创建新的线程。

    这种现象比较少见，也比较奇怪，主要是和jvm与系统内存的比例有关。

    这种怪事是因为JVM已经被系统分配了大量的内存（比如1.5G），并且它至少要占用可用内存的一半。有人发现，在线程个数很多的情况下，你分配给JVM的内存越多，那么，上述错误发生的可能性就越大。
    产生这种现象的原因如下（从这个blog中了解到原因：http://hi.baidu.com/hexiong/blog/item/16dc9e518fb10c2542a75b3c.html）：

    每一个32位的进程最多可以使用2G的可用内存，因为另外2G被操作系统保留。这里假设使用1.5G给JVM，那么还余下500M可用内存。这500M内存中的一部分必须用于系统dll的加载，那么真正剩下的也许只有400M，现在关键的地方出现了：当你使用Java创建一个线程，在JVM的内存里也会创建一个Thread对象，但是同时也会在操作系统里创建一个真正的物理线程（参考JVM规范），操作系统会在余下的400兆内存里创建这个物理线程，而不是在JVM的1500M的内存堆里创建。在jdk1.4里头，默认的栈大小是256KB，但是在jdk1.5里头，默认的栈大小为1M每线程，因此，在余下400M的可用内存里边我们最多也只能创建400个可用线程。

    这样结论就出来了，要想创建更多的线程，你必须减少分配给JVM的最大内存。还有一种做法是让JVM宿主在你的JNI代码里边。

    给出一个有关能够创建线程的最大个数的估算公式：

    （MaxProcessMemory - JVMMemory - ReservedOsMemory） / （ThreadStackSize） = Number of threads

    对于jdk1.5而言，假设操作系统保留120M内存：

    1.5GB JVM： （2GB-1.5Gb-120MB）/（1MB） = ~380 threads

    1.0GB JVM： （2GB-1.0Gb-120MB）/（1MB） = ~880 threads

    在2000/XP/2003的boot.ini里头有一个启动选项，好像是：/PAE /3G ，可以让用户进程最大内存扩充至3G，这时操作系统只能占用最多1G的虚存。那样应该可以让JVM创建更多的线程。

    因此这种情况需要结合操作系统进行相关调整。

    因此：我们需要结合不同情况对tomcat内存分配进行不同的诊断才能从根本上解决问题
Tags - , , , ]]> http://zhoujin.com/post/130/ <![CDATA[如何用程序指定Birt报表的JDBC Connection]]> chirs <> Sat, 12 Sep 2009 00:46:36 +0000 http://zhoujin.com/post/130/      Jason在“Birt world” blog中标题为“Using a supplied connection with BIRT”提供了很好的解决方案，可以通过修改oda jdbc plugins和IRunTask的setAppContext来实现程序控制数据连接方式。
     我根据实习需要把代码进行了相应修改，两个类分别继承于org.eclipse.birt.report.data.oda.jdbc.OdaJdbcDriver和Connection：

public class JdbcExistDriver extends OdaJdbcDriver{
    private final static String APPLICATION_BIRT_CONNECTION = "webreport.birt.connection";
    private Connection conn = null;
    public JdbcExistDriver() {
    }
    public IConnection getConnection(String string) throws OdaException {
        if(this.conn != null){
            ExistConnection jdbcConn = new ExistConnection();
            jdbcConn.conn = conn;
            return jdbcConn;
        }else{
            return new org.eclipse.birt.report.data.oda.jdbc.Connection();
        }
    }
    public void setAppContext(Object context) throws OdaException {
        Map ctx = (Map)context;
        this.conn = (Connection)ctx.get(APPLICATION_BIRT_CONNECTION);
    }
    public void setLogConfiguration( LogConfiguration logConfig )
                    throws OdaException{
        super.setLogConfiguration(logConfig);
    }
}

public class ExistConnection extends Connection {
    protected java.sql.Connection conn = null;
    public ExistConnection() {
        super();
    }
    public void close() throws OdaException {
        if(this.jdbcConn != null){
            this.jdbcConn = null;
        }
    }
    public void open(Properties properties) throws OdaException {
        this.jdbcConn = conn;
    }
}

copy 两个类到WEB-INF\platform\plugins\org.eclipse.birt.data.oda.jdbc_XXXXX\oda-jdbc.jar里;
修改plugin.xml文件，把
<dataSource
            odaVersion="3.0"
            driverClass="org.eclipse.birt.report.data.oda.jdbc.OdaJdbcDriver"
            defaultDisplayName="%datasource.name"
            setThreadContextClassLoader="false"
            id="org.eclipse.birt.report.data.oda.jdbc">

改为
<dataSource
            odaVersion="1.0"
            driverClass="xx.JdbcExistDriver"
            defaultDisplayName="exit driver"
            setThreadContextClassLoader="false"
            id="org.eclipse.birt.report.data.oda.jdbc">

程序调用修改为：
context.put("webreport.birt.connection",conn);

Tags - , , ]]> http://zhoujin.com/post/129/ <![CDATA[Birt 生成PDF中文乱码问题]]> chirs <> Sat, 05 Sep 2009 00:43:28 +0000 http://zhoujin.com/post/129/ Birt 是通过org.eclipse.birt.report.engine.fonts plugin来设置的，我们可以通过修改文件fontsConfig.xml来指定系统字体的路径以及字体对象PDF encoding；当然设计文件中指定的字体，运行系统中必须要有，否则就要指定本字体用其它字体代换.
Tags - , , ]]> http://zhoujin.com/post/128/ <![CDATA[struts2实践- 结合jquery的纯客户端js表单校验]]> chirs <> Tue, 01 Sep 2009 03:58:49 +0000 http://zhoujin.com/post/128/ 1.灵活性差
只有theme为xhtml和css_xhtml的时才能够启用纯客户端的js验证.
一般用户对页面UI表示都有一定的要求,当theme为xhtml或css_xhtml的时候会导致页面的排版和用户的UI要求不一致,而且几乎无法解决该问题.并且struts2纯js客户端的错误信息是利用动态添加一个tr来显示的.这就导致如果我想把错误和表单显示在同一行,利用struts2的客户端验证就很难做到.
2.默认支持的校验类型比较少.
struts2默认只支持比较少的几种验证类型例如
* required validator
* requiredstring validator
* stringlength validator
* regex validator
* email validator
* url validator
* int validator
* double validator
date和表达式验证都不支持.这给使用造成了一定的麻烦.
3.不支持客户端定制的js验证.
针对如上几点郁闷的地方,我在网上寻找了很久终于发现了一个比较好js客户端验证的框架
jquery-validate
该验证框架基于jquery这个js框架,利用jquery特性实现客户端的js校验,主要特点如下
1.支持基于表单类似声明式的js验证详细例子如下:
$("#signupForm").validate({
    rules: {
      firstname: "required",
      lastname: "required",
      username: {
        required: true,
        minlength: 2
      },
      password: {
        required: true,
        minLength: 5
      },
      confirm_password: {
        required: true,
        minlength: 5,
        equalTo: "#password"
      },
      email: {
        required: true,
        email: true
      },
      topic: {
        required: "#newsletter:checked",
        minLength: 2
      },
      agree: "required"
    },
    messages: {
      firstname: "Please enter your firstname",
      lastname: "Please enter your lastname",
      username: {
        required: "Please enter a username",
        minLength: "Your username must consist of at least 2 characters"
      },
      password: {
        required: "Please provide a password",
        minLength: "Your password must be at least 5 characters long"
      },
      confirm_password: {
        required: "Please provide a password",
        minLength: "Your password must be at least 5 characters long",
        equalTo: "Please enter the same password as above"
      },
      email: "Please enter a valid email address",
      agree: "Please accept our policy"
    }
  });

2.内置多种基本校验的类型(包括与ajax结合的服务器断校验)
required,remote(ajax服务器端校验器),minlength,maxlength,rangelength,min,max,range,email,url,date,,dateISO,dateDE,number,numberDE,digits,creditcard,accept,equalTo
3.支持自定义校验类型.
可以通过
$.validator.addMethod("phone", function(value) {
return validatePhone(value);
}, 'Please enter correct format for referee phone!');

添加自己的校验器
4.支持多种校验器的声明方式.
1).利用函数声明
请参考1点
2).结合控件属性声明
<input  type="radio" id="gender_male" value="m" name="gender" validate="required:true" />

3).结合控件的class属性声明
<textarea id="ccomment" name="comment" class="required">

这几种声明方式可以按照实际需要结合使用大大提高了灵活性.
Tags - , , , ]]> http://zhoujin.com/post/127/ <![CDATA[jquery的纯客户端js表单校验]]> chirs <> Fri, 28 Aug 2009 03:56:24 +0000 http://zhoujin.com/post/127/ http://bassistance.de/jquery-plugins/jquery-plugin-validation/
API: http://jquery.bassistance.de/api-browser/plugins.html
今天试了一下，还是比较方便的，主要是可以与jQuery结合起来做到与HTML分离.
官网的例子里引用了几个js和css文件，但只需引用jquery.validate.js这一个文件即可.
贴个简单的例子：
$('#EditView').validate({
             event: "keyup",
             rules:{
                 name:{required:true},
                 cosa_commodity_group_list:{required:true}
             },
             submitHandler:function(){
                 $("#group_list > option").attr("selected","selected");
                 $(this).submit();
             }
});

.event是触发校验的方式，可选值有keyup(每次按键时)，blur(当控件失去焦点时)，不使用这个参数时就只在按提交按钮时触发
2.如果在提交前还需要进行一些自定义处理使用submitHandler参数，其它的都比较简单，自己看看API就成了.
3.debug，如果这个参数为true，那么表单不会提交，只进行检查，调试时十分方便.
4.rules，所有的检验规则都写在这个参数里面.
格式为：        ID : {rule1,rule2,...}
          (1) required: true         必输
          (2) number: true 只能输入数字(包括小数)
          (3) digits:true 只能输入整数
          (4) minValue: 3 不能小于3
          (5) maxValue: 100 最大不超过100
          (6) rangeValue:[50,100] 值范围为50-100
          (7) minLength: 5 最小长度(汉字算一个字符)
          (8) maxLength:        10 最大长度(汉字算一个字符)
          (9) rangeLength:[5,10] 长度范围为5至10位(汉字算一个字符)
          (10) 上面的minLength, maxLength, rangeLength 这三项除了text input之外还可以用于checkbox,select这两种控件
          (11) email:true 电子邮件
          (12) equalTo: "#field" 与#field值相同
          (13) dateISO:true       日期型，格式为1998/01/22         1999-12-12
5.messages，自定义错误信息，格式与rules类似：
messages {
          password: {
              required: "请输入您的密码."
              minLength: "密码不能小于５位.",
              maxLength: "密码不能长于32位."
          },


Tags - , , ]]> http://zhoujin.com/post/126/ <![CDATA[Apache Wicket 1.4 发布]]> chirs <> Sat, 01 Aug 2009 15:09:11 +0000 http://zhoujin.com/post/126/
您可以通过修改maven pom.xml配置信息升级到最新的Wicket 1.4版本，修改代码如下：
<dependency>  
  <groupid>org.apache.wicket</groupid>  
  <artifactid>wicket</artifactid>  
  <version>1.4.0</version>  
</dependency>

当然您需要同时升级Wicket关联的一些模块，比如wicket-extensions等，不要把Wicket 1.3和Wicket 1.4 混用。
下面是一些Wicket 1.4版本中的重要变更：
Wicket 1.4泛型化了IModel接口和其实现类，提高了Wicket应用程序的类型安全。
Wicket 1.4中组件的getModel()方法和组件的setModel()方法，被重命名为getDefaultModel() 和 setDefaultModel()，以便更好的支持泛型models
Wicket 1.4的Spring模块已经被合并（wicket-spring-annot已经被声明为过期，现在可以直接使用wicket-spring）
Wicket 1.4中更新了大量的API,均使用Java 5语法特性的编写。
Wicket 1.4的 jar打包了metadata，方便与OSGI捆绑。
Tags - , , , ]]> http://zhoujin.com/post/125/ <![CDATA[当幸福来敲门The Pursuit of Happyness]]> chirs <> Wed, 01 Jul 2009 08:29:07 +0000 http://zhoujin.com/post/125/
一个穷途潦倒的单亲爸爸，因事业失败无家可归，却还得担起抚养儿子的重担。为了儿子的未来，他重新振作，终于皇天不负苦心人。
-----
Chris Gardner真实的故事，感谢威尔史密斯父子精彩的演绎,继续支持你们。

　　人生总有起伏，不可能一帆风顺，在最不如意的境遇时选对目标，坚持下去，未来将会很美好。黎明前的黑暗才是最可怕的，只要能挺过去，过后就是阳光，这是一部让人看到希望的影片，“希望”也许是上天给与人类最美好的事了。

　　片子一开始就能感觉到：Chris 夫妇之间的感情并不融洽，长期穷困的生活让妻子再也无法忍受，为了维持生计，一天经常会干16个钟头，还时不常的要抽出间歇时间照顾家庭，看这样一天天下去，没有任何起色，最起码在Chris身上看不到希望，最终选择了放弃。作为一个男人，对此表示理解。夫妻好比同林鸟，大难临头各自飞嘛！现实生活中有很多这样的例子，当然也有在这时候选择留下来与丈夫共度难关的。要知道两个人的力量维持一个家庭比一个人要大很多，就没那么困难了。假如选择了共度难关能否真正帮Chris获得成功呢？

　　是不是非得把人逼到那份儿上才会有所作为呢？如果引用“天将降大任于斯人也，必先苦其心志，劳其筋骨，饿其体肤，空乏其身，行拂乱其所为。”来理解的话，答案是肯定的，离开是必然的。结论是：压力越大，动力越大。

　　也有说：平生多磨砺，男儿自横行。所以现在正遭遇诸多不如意的朋友们，我们可以换个方式来看：放弃了就一定不会成功，坚持下去，别让任何人看不起你，包括自己，也许你就是下一个成功的人。

　　都说穷人的孩子早当家，这一点从小Chris身上可以看的很清楚：小Chris正是该无忧无虑的时候，却要经常跟着父亲去工作，跟父亲一起为了找个能睡觉的地方而到处奔波，居无定所。受了那么多委屈给爸爸的没有埋怨，只有鼓励。这是常人没有经历过的，也是常人无法做到的。

　　不是谁都能获得成功的。关键是你能否发现你的长处，并应用到合适的工作上。而且，从头再来不是谁都能做到的，因为会放不下，不甘心为了新的目标去放弃眼前的成绩，尽管眼前的成绩也不是那么的令人满意。试问：假如你现在是一名百货行业楼层经理，每天很努力地工作仍不能满足你当前对生活的需要，刚好你看到某个品牌公司的业务员收入很高，生活质量比你好上十倍，这是个新兴的公司，发展的空间很大，但是这个公司的门槛太高，竞争非常激烈，人才的选择近乎苛刻，而且自己的条件并不是最优秀的，但是在跑业务拉关系方面你有一定的天份，你愿意放下以前工作的经验，付出比别人更多的努力，从头开始，冒着万一失败了两手空空的风险，追求更高的生活质量，去实现你的价值吗？你真的能做到吗？所以：能从别人的成功中找到自己的目标，放下以前的成绩，从零开始竭尽全力去奋斗，相信别人能做到的我也能做到，这一点并不容易。如果能做到，我相信一定会成功。找到自己的长处，用在适合的地方，放下也是一种解脱。

　　这是一部意义深刻的影片，可能会改变你对生活和事业的看法，可能会影响到你的一生！

　　工作不开心、不满足的时候是否应该停下来想一想：这份工作真的适合我吗？有没有什么工作和事业能更充分的显示我的长处，发挥我更大的作用呢？一旦做出了新的选择，请告诉自己：不抛弃，不放弃，坚持到底就是胜利！要用比别人更多的付出换来自己目标价值的实现，追求属于自己的幸福！做好充分的心理准备：万事开头难，会遇到各种各样的困难，也会有各种各样的结果，设想一切可能失败的原因，找出应对的方法，成功就会更近一些。最后鼓励自己，乐观的出发：毕竟我比当年的Chris条件好很多。

　　最后赋诗一首，是我对生活的一点儿感叹，希望能唤起您的一点点共鸣！

　　为了生活我们付出很多，

　　生活也曾给与许多收获，

　　生活是曾经的波澜壮阔，

　　生活也经历着起起落落，

　　生活有太多的阴差阳错，

　　生活等我们努力去开拓！
Tags - ]]> http://zhoujin.com/post/124/ <![CDATA[Mac, 注意力，好的产品]]> chirs <> Mon, 01 Jun 2009 04:08:41 +0000 http://zhoujin.com/post/124/       有人说过，Mac能够显著提高生产力。我当时不以为然；然而现在在OSX上写着代码，我大概明白了为什么能显著提高生产力：原因在于注意力。

      看得出来Mac OSX花了很大的心思在让用户忽略OSX本身上。在使用HP 6515的时候，每次开机，右下角的那些驻留程序一个又一个的启动，浮出不同的提示告诉你，嘿，我启动成功了；我找到了一个无线网络，我连上了，等等。 Mac启动很快，大概二三十秒，短暂的开机音乐后，系统启动完成，上面浮出Finder的菜单，下面浮出Dock面板，机器就安静的等待着你的指令。无线网络自动连上了并且以深色显示在右上角上，没有多余的声音、动画。开启一个程序，菜单条在最顶上，这是因为任何一个稍具经验的聪明的用户使用菜单的频率都远小于使用窗口本身，加上快捷键的支持，菜单只是一个入门的手段。用户的注意力在窗口本身而不是菜单，既节约了屏幕空间，又节约了时间。

       Aqua界面简洁清爽。大多数成功的Web 2.0应用或多或少借鉴了osx的设计：看看Google Calendar和iCal；看看37Signals的产品。干净设计加上对用户注意力的保护，这种应用很难不在现今内容堆砌的web应用海洋中崭露头角。

      说到Mac，自然要提TextMate的。emacs和VIM的愤青族自然要保护他们钟爱的编辑器：功能强大，自定义能力极强，无所不能的编辑功能，等等。没错TextMate要比emac、vim在单文件的编辑上能力要弱，但是……问题是那么多功能，需要开发需要记忆的功能，你真得用得上吗？作为现代编辑器，基本的tab编辑，简单但是快速的项目支持，多文件导航，emacs, vim显得有点力不从心。更重要的是，根据大多数程序员的经验整理而出的Bundle, 是对开发生产力的极大提升。我想好的产品，除了功能不能弱之外──TextMate的编辑能力还是很强的──更重要的是不让程序员做重复的事情，特别是在动态语言如此流行的今天，TextMate这款编辑器做到了极致。没有很复杂的技术，没有超越emacs/vim的编辑能力，仅仅通过添加项目支持和 Bundle, 使得它的用户一经使用，便爱不释手。

      Mac带给我的不仅仅是一台新的机器，更重要的是提高了生产力，以及界面、交互上的一些思路以及在制造成功产品方面的一些思考。我更加坚信FreeOCS所走的“简单”的道路是正确的，事实上，无论产品的制造者如何考虑，产品的使用者总是希望产品能够带来强大功能的同时不丧失使用的简单性。
Tags - , , , ]]> http://zhoujin.com/post/123/ <![CDATA[AJAX: 模式？实践！]]> chirs <> Fri, 01 May 2009 04:04:02 +0000 http://zhoujin.com/post/123/ Tags - , ]]> http://zhoujin.com/post/122/ <![CDATA[我的。。。。。。]]> chirs <> Thu, 23 Apr 2009 02:30:24 +0000 http://zhoujin.com/post/122/ 态度暴虐暴虐
我困死了死了
再死一遍一遍 ]]> http://zhoujin.com/post/121/ <![CDATA[240多个jQuery插件]]> chirs <> Sat, 10 Jan 2009 13:21:22 +0000 http://zhoujin.com/post/121/ 概述

jQuery 是继 prototype 之后又一个优秀的 Javascript 框架。其宗旨是—写更少的代码,做更多的事情。它是轻量级的 js  库(压缩后只有21k) ，这是其它的 js 库所不jquery及的，它兼容 CSS3，还兼容各种浏览器（IE 6.0+, FF 1.5+, Safari  2.0+, Opera 9.0+）。 jQuery 是一个快速的，简洁的 javaScript 库，使用户能更方便地处理 HTML  documents、events、实现动画效果，并且方便地为网站提供 AJAX 交互。 jQuery  还有一个比较大的优势是，它的文档说明很全，而且各种应用也说得很详细，同时还有许多成熟的插件可供选择。 jQuery 能够使用户的 html 页保持代码和  html 内容分离，也就是说，不用再在 html 里面插入一堆js来调用命令了，只需定义 id 即可。今天在Kollermedia.at上发现了一篇JQuery插件列表的文章，特推荐如下。

文件上传(File upload)JQuery_001

Ajax File  Upload.
jQUploader.
Multiple File  Upload plugin.  
jQuery File Style.
Styling an input type  file.
Progress Bar  Plugin.

表单验证(Form Validation)

jQuery  Validation.
Auto  Help.
Simple  jQuery form validation.
jQuery  XAV - form validations.
jQuery AlphaNumeric.
Masked  Input.
TypeWatch  Plugin.
Text  limiter for form fields.
Ajax Username Check with  jQuery.  

表单－选取框(Form - Select Box stuff)

jQuery  Combobox.
jQuery  controlled dependent (or Cascadign) Select List.
Multiple Selects.
Select box  manipulation.
Select Combo  Plugin.
jQuery -  LinkedSelect
Auto-populate  multiple select boxes.
Choose Plugin (Select  Replacement).  

表单基本、输入框、选择框等(Form Basics, Input Fields, Checkboxes etc.)

jQuery Form Plugin.
jQuery-Form.
jLook Nice Forms.
jNice.
Ping  Plugin.
Toggle Form  Text.
ToggleVal.
jQuery Field  Plugin.
jQuery Form’n Field  plugin.
jQuery Checkbox  manipulation.
jTagging.
jQuery labelcheck.
Overlabel.
3  state radio buttons.
ShiftCheckbox  jQuery Plugin.
Watermark  Input.
jQuery Checkbox  (checkboxes with imags).
jQuery SpinButton  Control.
jQuery  Ajax Form Builder.
jQuery Focus  Fields.
jQuery Time  Entry.  

时间、日期和颜色选取(Time, Date and Color Picker)

jQuery UI  Datepicker.
jQuery date picker  plugin.
jQuery Time  Picker.
Time  Picker.
ClickPick.
TimePicker.
Farbtastic jQuery Color Picker  Plugin.
Color  Picker by intelliance.fr.  

投票插件(Rating Plugins)

jQuery  Star Rating Plugin.
jQuery Star Rater.
Content  rater with asp.net, ajax and jQuery.
Half-Star  Rating Plugin.  

搜索插件(Search Plugins)

jQuery  Suggest.
jQuery  Autocomplete.
jQuery  Autocomplete Mod.
jQuery  Autocomplete by AjaxDaddy.
jQuery  Autocomplete Plugin with HTML formatting.
jQuery  Autocompleter.
AutoCompleter (Tutorial  with PHP&MySQL).
quick Search jQuery Plugin.  

编辑器(Inline Edit & Editors)JQuery_002

jTagEditor.
WYMeditor.
jQuery  jFrame.
Jeditable  - edit in place plugin for jQuery.
jQuery editable.
jQuery  Disable Text Select Plugin.
Edit  in Place with Ajax using jQuery.
jQuery Plugin - Another  In-Place Editor.
TableEditor.
tEditable -  in place table editing for jQuery.  

多媒体、视频、Flash等(Audio, Video, Flash, SVG, etc)

jMedia -  accessible multi-media embedding.
JBEdit - Ajax online Video  Editor.
jQuery MP3  Plugin.
jQuery Media  Plugin.
jQuery Flash  Plugin.
Embed  QuickTime.
SVG Integration.  

图片(Photos/Images/Galleries)

ThickBox.
jQuery lightBox  plugin.
jQuery  Image Strip.
jQuery  slideViewer.
jQuery  jqGalScroll 2.0.
jQuery  - jqGalViewII.
jQuery  - jqGalViewIII.
jQuery  Photo Slider.
jQuery  Thumbs - easily create thumbnails.
jQuery jQIR Image  Replacement.
jCarousel  Lite.
jQPanView.
jCarousel.
Interface Imagebox.
Image  Gallery using jQuery, Interface & Reflactions.
simple jQuery Gallery.
jQuery Gallery Module.
EO Gallery.
jQuery  ScrollShow.
jQuery Cycle  Plugin.
jQuery  Flickr.
jQuery  Lazy Load Images Plugin.
Zoomi -  Zoomable Thumbnails.
jQuery  Crop - crop any image on the fly.
Image Reflection.  

Google地图（Google Map）

jQuery Plugin  googlemaps.
jMaps jQuery Maps  Framework.
jQmaps.
jQuery & Google  Maps.
jQuery Maps  Interface forr Google and Yahoo maps.
jQuery J Maps - by Tane Piper.  

游戏(Games)

Tetris with  jQuery.
jQuery Chess.
Mad  Libs Word Game.
jQuery  Puzzle.
jQuery  Solar System (not a game but awesome jQuery Stuff).  

表格等(Tables, Grids etc.)

UI/Tablesorter.JQuery_003
jQuery ingrid.
jQuery Grid Plugin.
Table  Filter - awesome!.
TableEditor.
jQuery Tree  Tables.
Expandable  “Detail” Table Rows.
Sortable  Table ColdFusion Costum Tag with jQuery UI.
jQuery  Bubble.
TableSorter.
Scrollable  HTML Table.
jQuery  column Manager Plugin.
jQuery  tableHover Plugin.
jQuery  columnHover Plugin.
jQuery  Grid.
TableSorter  plugin for jQuery.
tEditable -  in place table editing for jQuery.
jQuery charToTable  Plugin.
jQuery Grid Column  Sizing.
jQuery Grid Row  Sizing.  

统计图(Charts, Presentation etc.)

jQuery  Wizard Plugin .
jQuery Chart  Plugin.
Bar Chart.  

边框、圆角、背景(Border, Corners, Background)

jQuery Corner.
jQuery  Curvy Corner.
Nifty jQuery  Corner.
Transparent  Corners.
jQuery  Corner Gallery.
Gradient  Plugin.  

文字和超链接(Text and Links)

jQuery  Spoiler plugin.
Text  Highlighting.
Disable Text  Select Plugin.
jQuery  Newsticker.
Auto  line-height Plugin.
Textgrad - a text gradient  plugin.
LinkLook - a link  thumbnail preview.
pager jQuery  Plugin.
shortKeys jQuery  Plugin.
jQuery  Biggerlink.
jQuery Ajax Link  Checker.  

鼠标提示（Tooltips）

jQuery  Plugin - Tooltip.
jTip - The jQuery Tool  Tip.
clueTip.
BetterTip.
Flash  Tooltips using jQuery.
ToolTip.  

菜单和导航(Menus, Navigations)

jQuery Tabs Plugin - awesome!  . [demo nested  tabs.]
another  jQuery nested Tab Set example (based on jQuery Tabs Plugin).
jQuery idTabs.
jdMenu - Hierarchical Menu  Plugin for jQuery.
jQuery SuckerFish  Style.
jQuery  Plugin Treeview.
treeView Basic.
FastFind  Menu.
Sliding  Menu.
Lava Lamp jQuery  Menu.
jQuery  iconDock.
jVariations  Control Panel.
ContextMenu  plugin.
clickMenu.
CSS Dock  Menu.
jQuery  Pop-up Menu Tutorial.
Sliding  Menu.

http://stilbuero.de/jquery/tabs_3/  

幻灯、翻转等(Accordions, Slide and Toggle stuff)

jQuery  Plugin Accordion.
jQuery Accordion Plugin  Horizontal Way.
haccordion  - a simple horizontal accordion plugin for jQuery.
Horizontal  Accordion by portalzine.de.
HoverAccordion.
Accordion Example from  fmarcia.info.
jQuery  Accordion Example.
jQuery Demo - Expandable  Sidebar Menu.
Sliding Panels for  jQuery.
jQuery  ToggleElements.
Coda  Slider.
jCarousel.
Accesible News Slider  Plugin.
Showing and  Hiding code Examples.
jQuery Easing Plugin.
jQuery Portlets.
AutoScroll.
Innerfade.  

拖放插件(Drag and Drop)

UI/Draggables.
EasyDrag  jQuery Plugin.
jQuery Portlets.
jqDnR - drag, drop resize.
Drag Demos.  

XML XSL JSON Feeds

XSLT Plugin.
jQuery  Ajax call and result XML parsing.
xmlObjectifier -  Converts XML DOM to JSON.
jQuery XSL  Transform.
jQuery Taconite -  multiple Dom updates.
RSS/ATOM  Feed Parser Plugin.
jQuery  Google Feed Plugin.  

浏览器(Browserstuff)

Wresize  - IE Resize event Fix Plugin.
jQuery ifixpng.
jQuery pngFix.
Link Scrubber -  removes the dotted line onfocus from links.
jQuery  Perciformes - the entire suckerfish familly under one roof.
Background  Iframe.
QinIE - for  proper display of Q tags in IE.
jQuery Accessibility Plugin.
jQuery MouseWheel  Plugin.  

对话框、确认窗口(Alert, Prompt, Confirm Windows)

jQuery Impromptu.
jQuery Confirm Plugin.
jqModal.
SimpleModal.  

CSS

jQuery  Style Switcher.
JSS - Javascript  StyleSheets.
jQuery Rule -  creation/manipulation of CSS Rules.
jPrintArea.  

DOM、AJAX和其它JQuery插件（DOM, Ajax and other jQuery plugins）

FlyDOM.
jQuery Dimenion  Plugin.
jQuery  Loggin.
Metadata -  extract metadata from classes, attributes, elements.
Super-tiny  Client-Side Include Javascript jQuery Plugin.
Undo  Made Easy with Ajax.
JHeartbeat - periodically poll  the server.
Lazy  Load Plugin.
Live  Query.
jQuery Timers.
jQuery Share it - display  social bookmarking icons.
jQuery  serverCookieJar.
jQuery  autoSave.
jQuery  Puffer.
jQuery iFrame  Plugin.
Cookie  Plugin for jQuery.
jQuery Spy - awesome  plugin.
Effect Delay  Trick.
jQuick - a quick tag  creator for jQuery.
Metaobjects.
elementReady.  

英文：http://www.kollermedia.at/archive/2007/11/21/the-ultimate-jquery-plugin-list/


Tags - , ]]> http://zhoujin.com/post/119/ <![CDATA[纪念周总理！ ]]> chirs <> Thu, 08 Jan 2009 10:20:54 +0000 http://zhoujin.com/post/119/ 今天1月8号了，让我们大家一起缅怀周总理！
点击在新窗口中浏览此图片
人民的总理，永远存于我们的心中。
总理永远活在我们的心中！
深鞠躬~~！！！然后深切缅怀！！
Tags - , ]]> http://zhoujin.com/post/120/ <![CDATA[基于jQuery的表单验证插件]]> chirs <> Mon, 05 Jan 2009 13:18:12 +0000 http://zhoujin.com/post/120/
      请自行下载插件帮助文档，里面有例子，还有包含插件。如若碰到问题，或bug,或者建议，请联系本人。

本人第一次写博客，欢迎大家来踩踩。。。。
点击这里下载文件

Tags - , , ]]> http://zhoujin.com/post/118/ <![CDATA[生命 爱情 旅行]]> chirs <> Sun, 30 Nov 2008 16:00:00 +0000 http://zhoujin.com/post/118/ 身体越来越糟糕，像超负荷运转的零部件一样，不时出现这样那样的毛病，不知道哪天哪一部位就会罢工停摆拒绝运转。

不想去医院，不喜欢那股浓浓的来苏尔味道，不喜欢那每日都上演着生生死死欢笑悲泣的地方。不敢想象自己的身体真的出了问题，需要躺在那儿，自己内心会是怎样的苍凉。面对死，我会很坦然。可我却惧怕活着时那种欲罢不能的折磨。

早就明白，生命只是一场旅行，我们每个人都坐在时间的列车上，开始自己的行程。沿途，有风景无数险恶无数，也会有不同的人与我们邂逅，陪我们一程路途，然后各自西东而去。

人生太短暂太苍促，出生、死亡，谁都无法幸免，起点，终点，谁都会安于同一地平线下面，不同的只是，有人的一生平步青云，快乐幸福会多于痛楚，有人的一生荆棘满途，苦难沧桑多于幸福。无论前者还是后者，终其一生也不过只是由一些爱恨情愁、喜怒哀乐交织而成的黑白片段，最终会涅灭成灰。

睁着双眼，任凭黑暗将自己包围。仰望天际，一弯新月，两颗亮晶晶的星星，双星伴月，少见的奇观。原来，月亮并不寂寞，虽然它与星星有着遥不可及的距离。寂寞的是我们这颗凡尘俗世带有贪念的心。

打开播放器，带着迷幻味道的音乐响起，有空灵的女声在边沧桑的耳语，让人沉迷。边，听边有一句没一句的和朋友聊着天，那一段纠缠了她五年多的网络情感，在我刻薄尖酸一针见血的言词中终是尘埃落定。无论她在我面前用言辞掩饰得多少洒脱，从她忍不住滴落的泪水里，我还是看到了绝望、失落与不甘，情关难度，即使看透看破亦是枉然。

男女间的感情，最终都要输给时间。在分针秒针滴答滴答的声音里，会变得千疮百孔。曾经的激情已沦为如今的厌倦，相思不再温存不再，一切的一切，均以如鸡肋般食之无味，弃之如草履是迟早的事情。

爱情，只是沙漠深处那一泓浅浅的湖水，干涸是它唯一的结局。那一双曾经柔情似水让我们沉醉其中的眼眸，最后的最后都将变成沙漠，我们睡在彼此眼睛的沙漠里，看着自己同爱情一道死去。活在爱情里的男女，如同沙漠浅泓中的一尾鱼，畅游后是苦苦的挣扎，然后不情不愿不甘心的咽下最后一口气。

所幸自己是薄情的男子，这世上没有人能让我依恋，所以我迷恋自己迷恋音乐迷恋文字。好在自己是健忘善变的男子，这世上没有哪个女子能让我刻骨铭心伤痛一辈子，只是请相信,爱你的时候我是真的在爱你,忘记的时候是真的已忘了你，纵使当时再难舍再痛楚，过后，我一定会恢复到最初。

曾经我也柔情似水，曾经付出真心只想换来丁点儿的温暖与安慰，然而结局没有一点点的完美，所以开始对所有人都防备，因为距离让我觉得实实在在的安全。

某些人某些事，在我心里已如春之花凋秋之叶落，终是腐败成尸，连掩埋都不值。

薄情是我亦是你。

夜，黑得深了。音乐来来回回在我寂寞空洞的房子里播放着，时间像筛下的沙粒慢慢泻下来，我醒在沙漠深处，看红尘繁华故事，艰难的一步一步踏沙而行。我在失水的世界里幽闭自己，看着那些与爱情有关的令人沮丧令人绝望的人与事，渐渐的掩埋于沙里。

我的眼睛里，有了沙子，硌得生疼，却是没有泪水流得出。 ]]> http://zhoujin.com/post/116/ <![CDATA[对乒乓球失去兴趣]]> chirs <> Thu, 21 Aug 2008 08:34:22 +0000 http://zhoujin.com/post/116/
每次都是包揽，这样的比赛已经失去了意义，我现在一看乒乓球比赛都希望中国队输，包括这次奥运会，这样对乒乓球这项运动才是有益的。否则，到最后只有中国人才玩乒乓球，如果这样，我真希望下一届奥运会取消掉乒乓球比赛。

更加没劲的是，中央台居然找了一个过气的杨影来当乒乓球比赛的解说，一听到她讲话，再好看的比赛我都会换台，经常她解说的比赛，嘉宾都是“嗯、啊、是、哦”的反应，整得跟叫床似的。以为自己很有能耐，可是请来的嘉宾哪个在以往的比赛都比她强100倍。

而且这并非我一家之言，多数人都对杨影的解说嗤之以鼻，中央台任何一个非此专业的解说都比她强。让杨影下去吧，否则没人看乒乓球了。。。。。。人家解说要钱，杨影解说要命啊。
Tags - ]]> http://zhoujin.com/post/115/ <![CDATA[困惑]]> chirs <> Wed, 16 Jul 2008 04:28:30 +0000 http://zhoujin.com/post/115/
文学在我身上渐渐复苏起来。我不知道为这种感觉该哭还是笑。我都以为自己的精神世界将要枯竭的时候，文学，艺术等等都将离我而去的时候，文人才有的迷茫、深思、激情却在我脑海中渐渐浮现。然而，仅有的这些冲动远远不能推动创作，远远不能写出理智而具有分量的东西。还需要沉淀。然而，对于沉淀，我这个曾经迷失于沉淀的人，是否能够把握呢？

写下的每一篇文字都不满意，都觉得没有表达自己真正的意思。然而，如同小学课本上的《最后一只小板凳》，这篇文字目的是保持沉淀状态，而不是沉沦。权当自己写过便扔的纸条罢了。

为什么看镜子中的东西，左右是颠倒的，而上下却不颠倒？
为什么时间只向一个方向运动，我们可以知道过去，不能影响过去；我们不知道将来，可以影响将来？
眼睛只能看到大脑相信的东西？
我们所认识的世界，是确实存在的，还是我们自己想象出来的？ ]]> http://zhoujin.com/post/114/ <![CDATA[控制发散思维]]> chirs <> Sat, 12 Jul 2008 04:06:43 +0000 http://zhoujin.com/post/114/
      现在设计平台，发现陷入了这样一个怪圈：我总想将最新最好的开源产品集成到平台中，却忽略了Roadmap Feature的定义，也就是说，没有一个清晰的标尺来定义平台某一个版本应该包含那些特征，应该达到什么效果。这样做的后果是我陷入在一个又一个优秀的产品中，像上瘾的烟鬼拔不出来。在深邃的开源世界里，一切的一切都太又诱惑了：为了选定一种O/R映射方案，我比较了JDO的各种实现以及Hibernate，阅读了大量文档（广告？），最后还是回归到Hibernate; 为了选定一种Mock测试方案，我比较了EasyMock, jMock, 之前我从未用过Mock测试，现在我对EasyMock的机制已经相当清楚了；为了选定一种代码覆盖率工具，我比较了Clover, Jcoverage和Emma，最后选定了Jcoverage， 为了选择一种IoC容器，我比较了Spring和 HiveMind，最后选定Spring, 为了选定一种Web开发框架，我重新审视并比较了SpringMVC, WebWork, Struts, Tapestry.，最后选定了Tapestry。这个过程充满了感叹，也充满了诱惑性：很多具有相关性设计精美的项目会时不时招摇的在你眼前晃来晃去，让你忍不住看下去，然后你一个下午的光阴就耗费在从Google或者TSS或者JavaLobby一个链接开始而引入的一个深渊，留下你无法弥补的4个小时的时间。看着越来越近的Release Date, 心情越来越不爽。

      因此，一旦前期调研结束，程序员应当果断的将与开源的联系一举切断，专心致志的投入到实现中去，一旦发现有可能抠出新的设计的地方，不要马上就找开源的产品，请先用自己的智慧设计一个能用哪怕是破败不堪的（好的设计是重构出来的，不是吗？）东西，先将框架搭建出来，一个迭代过后，开始重构，等到这个设计基本成型了，能够运行了，然后重新获得与OS的联系，参考同类产品，进行重构或者集成。这么做的目标是控制住发散的思维，在有限的时间内拿出一个在当前状态下最好的方案与实现，没有底线的项目/产品是个毫无意义的泡泡，脆弱，除了作为夸夸的谈资，经不起明眼人的一锥子。
Tags - , ]]> http://zhoujin.com/post/113/ <![CDATA[雨夜静思！ ]]> chirs <> Fri, 11 Jul 2008 14:29:32 +0000 http://zhoujin.com/post/113/       自己最近病了，每天的晚上想的就会多了，感觉累了，不是身体累了，心里累了？好像也不是，那就是————生命累了！这样说也不知道贴切不贴切，但是只能眼下联想到这个了....

       “人活着累不累？”有人这样问。

      东方哲人应曰：“天将降大任于斯人也，必先苦其心志，劳其筋骨，饿其体肤，空乏其身……，你说人活着累不累?

      西方哲人又写道：“你隐没在黑夜里，周围的人都睡着了，而你，整夜不睡，你是守夜者之一，在你挥动的火把下，你瞥见脚下燃烧的火更近了……你为什么通宵不眠?必须有-个守夜，大家都这么说!必须有一个。“从本质上说，我们每个人都是守夜人，不论是天才还是凡人。守夜人不仅劳累，而且孤独，但世界因了这个守夜人的呵护，没有了孤独和惧怕。这时，守夜人的累上升成一种审美的观照，成了人类心灵的守护神，在他不息不歇的火把下，我们看到了美神与爱神携手并肩地微笑。 ]]> http://zhoujin.com/post/111/ <![CDATA[圣斗士星矢的状态模式和观察者模式]]> chirs <> Mon, 07 Jul 2008 01:18:06 +0000 http://zhoujin.com/post/111/ 雅典娜：动画片《圣斗士星矢》的女猪脚，自称女神，手下有88个男人为他卖命。
状态模式：为了方便的控制状态的变化，避免一堆IF／ELSE，以及状态规则改变的时避免代码改动的混乱。
观察者模式：一个被观察者一动，多个观察者跟着动，经常用于界面UI。

话说星矢和很强的某斗士甲对打，雅典娜在一边看，星矢总是挨揍，每次挨揍完之后星矢的状态总是会发生一些变化：

正常－－挨打－－瀕死－－挨打－－小宇宙爆发－－挨打－－瀕死－－挨打－－女神护体－－挨打（星矢无敌了，打也没用，战斗结束）－－正常

以上状态转变用状态模式来表现，一个Saiya类代表星矢，一个SaiyaState代表他的状态，SaiyaState下面有多个子类，分别代表星矢的多种状态，如正常NORMAL、瀕死DYING、小宇宙爆发UNIVERSE、女神护体GODDESS，即把状态抽象成对象，在每种状态里面实现被打的时候所需要更改的状态，这样就避免了每次被打都要进行一次IF/ELSE的判断。
public class Saiya extends Observable {  
    //定义星矢的四种状态  
    public final SaiyaState NORMAL = new NormalState(this);  
  
    public final SaiyaState DYING = new DyingState(this);  
  
    public final SaiyaState GODDESS = new GoddessState(this);  
  
    public final SaiyaState UNIVERSE = new UniverseState(this);  
      
    private SaiyaState state=NORMAL;  
      
    private SaiyaState laststate=null;  
      
    public void hit(){  
        //调用当前状态的被打方法 反过来改变自己的状态  
        state.hit();  
    }  
    public String status(){  
        //当前状态名  
        return state.status();  
    }  
      
    protected void setState(SaiyaState state){  
        laststate=this.state;  
        this.state=state;  
        //观察者模式  
        setChanged();  
        notifyObservers("星矢状态变化");  
    }  
      
    public String getlastStatus(){  
        return laststate.status();  
    }  
}

星矢的状态
public abstract class SaiyaState {  
    protected Saiya saiya;  
  
    public SaiyaState(Saiya saiya) {  
        this.saiya = saiya;  
    }  
      
    public String status(){  
        String name=getClass().getName();  
        return name.substring(name.lastIndexOf(".")+1);  
    }  
    //星矢被打了  
    public abstract void hit();  
}

在每种状态里面实现被打的时候所需要更改的状态，例如小宇宙爆发状态下被打
public class UniverseState extends SaiyaState {  
  
    /**  
     * @param saiya  
     */  
    public UniverseState(Saiya saiya) {  
        super(saiya);  
  
    }  
  
    /* 小宇宙爆发状态被打进入瀕死状态  
     *  
     */  
  
    public void hit() {  
        saiya.setState( saiya.DYING);  
  
    }  
}
  
雅典娜在一边看，星矢每次被打她都要给星矢加油，她是个观察者，星矢是被观察者，这里星矢实现java.util.Observable，每次被打hit就notifyObservers，雅典娜就加油。
public class Athena implements Observer {  
  
    /* 我是雅典娜 我是观察者  
     *  
     */  
    public void update(Observable arg0, Object arg1) {  
        System.out.println("雅典娜说：星矢加油啊！！！");  
        }  
  
}

总的来看 这个过程就是这样子：
public class StateMain {  
    public static void main(String[] args) {  
  
        Saiya saiya = new Saiya();  
        Observer athena = new Athena();  
        saiya.addObserver(athena);  
        System.out.println("星矢最初的状态是：" + saiya.status());  
        for (int i = 0; i < 5; i++) {  
            System.out.println("星矢被揍了" + (i + 1) + "次");  
            saiya.hit();  
            System.out.println("星矢现在的状态是：" + saiya.status());  
        }  
    }  
}  

结果星矢在雅典娜的帮助下，有惊无险的战胜了很强的某斗士甲：
星矢最初的状态是：NormalState  
星矢被揍了1次  
雅典娜说：星矢加油啊！！！  
星矢现在的状态是：DyingState  
星矢被揍了2次  
雅典娜说：星矢加油啊！！！  
星矢现在的状态是：UniverseState  
星矢被揍了3次  
雅典娜说：星矢加油啊！！！  
星矢现在的状态是：DyingState  
星矢被揍了4次  
雅典娜说：星矢加油啊！！！  
星矢现在的状态是：GoddessState  
星矢被揍了5次  
雅典娜说：星矢加油啊！！！  
星矢现在的状态是：NormalState  

总结：状态模式的缺点就是会弄出很多子类，如果状态没那么复杂，状态规则改变的可能性比较小的话就不要用了
Tags - , ]]> http://zhoujin.com/post/112/ <![CDATA[css定义几种格式]]> chirs <> Fri, 04 Jul 2008 01:44:43 +0000 http://zhoujin.com/post/112/    html{/*<定义网页结构总体样式>*/}
   body{/*<定义页面属性>*/}
    div{/*<定义div元素的属性>*/}
   span{/*<定义span元素的属性>*/}

2. id选择符
       #top {/*<定义id为top元素的文本颜色为red>*/ color:red;}
       #top div{/*<定义id为top的所有子div元素样式,但不包含id为top的样式>*/}
       #top .child1{/*<子级样式一>*/}
       #top .child2{/*<子级样式二>*/}
      <div id="top">我是div</div>

3. class 选择符
          这个就不说了

4. 分组选择符
       h1,h2,h3,h4,h5,h6,p{/*<定义所有级别的标题和段落行高都为字体大小的1.6倍>*
                                           line-height:1.6em;
       /}
       .class1,class2{{/*<所有这些class类型样式>*/}

5. 包含选择符
    .div1 h2 p span{/*多层包含选择符*/
                                  font-size:18px;
    }

6.  元素指定选择符
    span.red{/*定义div元素中class为red元素的颜色为红色*/
                color:red;
    }

    span#top{/*定义div元素中id为top元素的颜色为红色宽度为百分之百*/
                width:100%;
    }

7. 子对象选择符
      #main > table{/*定义id为main的主体模块中子对象table的样式*/}

      #main > .title{/*定义id为main的主体模块中子对象class为title的样式*/}

以上是定义css格式的语法格式,但是不同格式也让样式具有优先级,简单说下优先级顺序:
    id选择符 >  class选择符 > 类型选择符
Tags - , , ]]> http://zhoujin.com/post/110/ <![CDATA[记忆]]> chirs <> Tue, 01 Jul 2008 02:30:04 +0000 http://zhoujin.com/post/110/
记忆，本身是空白的，然而，人们将多种元素加入到记忆中，当经历了人生的酸甜苦辣后，记忆变成了调味品，它不再只是幸福的寄托，也加入了辛酸的味道。

人生，本身是一成不变的，然而，人们却给予太多的幻想，所以，当梦想变为现实时，人生也被定义成另外一个角色，缥缈般的，来了，去了。。。

我在写字间游走，也在爱恨间穿梭，记忆时而清晰，间或模糊，只在想念地每一个瞬间。。。

当秋风拂起下一片落叶的时候，你是否会想起我？如同我思念你般地记起我们的曾经，还有那些抹不去的记忆。。。
Tags - , , ]]> http://zhoujin.com/post/109/ <![CDATA[关于软件架构设计]]> chirs <> Wed, 25 Jun 2008 02:10:38 +0000 http://zhoujin.com/post/109/
1、软件逻辑架构设计，逻辑架构设计主要设计软件的模块组成，模块分层，模块间的接口和契约，只有细化模块设计的时候，才可能考虑到所谓三层结构问题，可能很多的人都把模块的细化设计看成了架构设计
2、系统架构设计，系统架构设计要考虑的问题就是系统的伸缩性，可扩展性，安全性，稳定性、高性能性等方面的问题，这个时候主要考虑WEB服务器、数据库服务器怎么部署，考虑热备问题，大缓存问题，集群问题、加密访问(如VPN)等方面的问题。这里面会涉及到大量的性能估算问题，这才是考验功力的地方。
3、物理架构设计，物理架构设计主要考虑硬件的物理放置问题，要考虑到流量的分配、代理问题等，这方面我不是很了解。

对软件架构的设计居然在相当长的一段时间里面存在误区，居然把软件架构设计和程序框架结构设计混淆等同，以为就架构设计就是设计那些三层结构怎么划分，怎么流转的问题!
Tags - ]]> http://zhoujin.com/post/108/ <![CDATA[Visitor - 访问者模式]]> chirs <> Mon, 23 Jun 2008 16:05:56 +0000 http://zhoujin.com/post/108/
业务员此时典型的工作流程是：
if (service instanceof Saving){  
    //存款  
   ......  
}else if (service instanceof Draw){  
    //提款  
   ......  
}else if (service instanceof Fund){  
    //基金  
   ......  
}    
......

于是每位业务员的桌面总是塞得满满的，更重要的是大量的时间都花在受理不同业务之间的切换，使得效率很低。

有没有方法能够使得业务员的工作效率提高呢？银行经理苦思冥想了半天，终于想出了一个好办法。他让每个窗口各负责一个业务，同时委任了一位访问者(Visitor)，负责在客户进门时，询问他要办理什么业务，告诉他应该去哪个窗口办理。这样，每个窗口的业务员就只负责一项业务，减少了在不同业务间切换的时间耗费，效率大大提高。更重要的是，当某一项业务的处理流程发生变更时，不需要同时麻烦三个窗口的业务员，而只需要让处理这项业务的业务员进行修改就可以了。

下面就来定义Visitor类，这个Visitor类实际上还办含了不同窗口受理员的职责，可以认为是银行的受理反应机制吧。
public class Visitor {  
      
    public void process(Service service){  
        // 默认业务  
    }  
      
    public void process(Saving service){  
        // 存款  
    }  
      
    public void process(Draw service){  
        // 提款  
    }  
      
    public void process(Fund service){  
        // 基金  
    }  
}  

接着我们定义业务基类。
public class Service {  
    public void accept(Visitor visitor) {  
        visitor.process(this);    
    }  
}

不同的业务类。
public class Saving extends Service {  
    //各种业务处理流程  
}

public class Draw extends Service {  
    //各种业务处理流程  
}

public class fund extends Service {  
    //各种业务处理流程  
}

好了，接下来就是我们的访问者与到来的客户之间的交互了。
public class Client {  
    public static void main(String[] args) {  
        Service s1 = new Saving();  
        Service s2 = new Draw();  
        Service s3 = new Fund();  
          
        Visitor visitor = new Visitor();  
          
        s1.accept(visitor);  
        s2.accept(visitor);  
        s3.accept(visitor);  
    }  
}

后话：专门设定一个访问者的职位还是有点多余，于是后来银行经理请设备公司做了一个排号机来代替访问者。

总结

Visitor模式实际上是利用的语言本身的特性，见Vistor类的各个函数，通过不同的参数来自动查找相应的处理函数。

采用Visitor的好处如上面说到的那样，当需要改变其中一项业务的处理时，不需要每个地方都进行修改，而只需要改动Visitor类中相应的处理函数就可以了。也就是说它适合于业务处理时常发生变动的情况。

当然，Visitor也有它自身的限制。它不适合于业务数量的经常变化，因为一旦新增或删除一些Service时，需要对visitor进行相应的增删。也就是说具体Service与Visitor是耦合的。
Tags - , ]]> http://zhoujin.com/post/105/ <![CDATA[opoa项目实践]]> chirs <> Mon, 23 Jun 2008 06:32:40 +0000 http://zhoujin.com/post/105/       One Page, One Application(后面缩写为OPOA，或者1P1A)， 含义很简单：一个页面就是一个应用。不再使用iframe, 页面提交不能再使用submit方式。

      在众多的基于Web的MIS系统中，没有人关心页面的组织形式；大多数稍微复杂的MIS系统，都采用分祯(Frame)的方式来组织页面，这样，在进行业务操作的时候，url的变化表现在一个框架页面内，从浏览器的地址看起来，只有一个地址；更有甚者，一些应用干脆弹出一个去掉了浏览器菜单、工具条、地址栏、状态栏的窗口（比如招商银行、民生银行的网上银行系统），连地址都看不见。因此，一个页面就是一个应用，从用户的角度来说，对于操作型系统，是一种非常自然的体现。用户无需了解每一个具体的操作对应的地址是什么。

      这种设计背后的含义实际是：是希望由程序来控制用户的行为，还是反过来。在操作型系统中，每一步的操作往往被业务含义严格定义，无论是应用的设计者，还是其使用者，都希望在一种受控的状况下来进行操作。例如，一个审批动作，用户更希望是通过一个按钮来触发，而不是访问类似于/approve.action?itemid=123的方式。

      这样的好处是：很多东西，例如：JS，CSS，HEAD等整个系统都只需加载一次。加快响应速度。客户体验也有所提高，不再弹出窗口，不再整个页面进行刷新。

二 场景
      显然，OPOA的设计只能针对那些对URL不敏感的系统，或者说操作型系统。绝大多数MIS系统都属于这一范畴，Email系统也是这一范畴，其他领域，如监控系统，聊天室等都可以采用这种思路。反面的例子是，对于内容型系统，如新闻系统，Blog系统，论坛系统，用户更希望能够通过一个明确的URL来定位页面内容，搜索引擎也喜欢这种地址。这种应用需要的是一个合理，易懂，明确的地址。

三 设计与实现
      大多数MIS系统，无论是有意识或者无意识，都遵循了OPOA的思路。要么采用框架，要么采用弹出窗口来屏蔽URL的直接访问。实现上也很简单，这里就不再赘述了。注意到上述的OPOA地实现只是对用户而言，看起来好像是一个页面一样，但实际上还是有众多的action， page在后面工作。

      下面我要说的一种实现是，采用buffalo技术来实现真正意义上的OPOA. 简而言之：主页面（或者称布局页面）只加载一次，其他的操作页面通过buffalo技术来加载，并将其中的操作脚本与布局内容分开，最后进行展示。

      首先存在一个布局页面，这个页面定义了一个应用大致的外观，（例如，大部分MIS系统按照上中下三栏，中间部分左右两栏分别为顶部logo, 操作菜单，具体操作内容，底部状态栏）。用你喜欢的网页编辑工具，将这个页面设计美观，然后按照应用的要求，将页面进行拆分。此时的拆分不用Frame了，只需要在不同的部位加上
就可以。
然后在主页面定义一个函数，例如switchPage, 将这个函数使用在需要进行页面切换的地方。switchPage函数这样实现：
function switchPage(page) {
     pageBuffalo.remoteCall(”pageService.loadPage”, [page], function(reply) {
            var pageObj = reply.getResult();
            Buffalo.getElementById(”body”).innerHTML = pageObj.html;
            if (pageObj.script != null || pageObj.script != “”) {
                  execScript(pageObj.script);
            }
    });
}

      剩下的工作都可以想象了。你可以将web应用的网页资源全部用html编写，并放在一个不为人知的地方，而通过pageService来读取他们；你可以任意组织你的应用外观，更加自如的切换他们。应用的URL地址永远只有真正的一个，你的应用也要比别人快很多，因为只加载那么一小块内容。

项目实践过程中遇到的问题：

     1. 须保证页面元素ID唯一，全系统JS函数名唯一 [定义一个规范]

     2. 回调函数处理 [封闭buffalo提交的方式，增加回调处理]

     3. FORM提交 [使用buffalo的form提交]

     4. JS加载问题 [使用与buffalo组件绑定的方式加载]

    5. 事务同步问题 [通过设置buffalo提交参数，并且自己在回调进行特殊处理]
     ……

四 小结
      AJAX的兴起为我们开阔了很多视野。比起原来的web框架，这种OPOA的方式能够更快，减少更多的编码量，并提供更好的用户体验。当然，上文中提出的只是一个原型实现，如果尝试自行实现，可能更多的东西需要考虑，如安全，缓存，事件回调机制，内存管理等等。但这将是一个方向，一个可以提高开发体验与用户体验的方向。

      这是我们项目第一次使用OPOA思想，在大概一个月的摸索道路上，需要解决的问题是比较多的。而且前期开发的压力也是比较大！思想不同了，处理方式不同了，带来了更高的客户体验！ 有得必有失，权衡中间的得失才是最重要的！我们正在成长，在OPOA的道路上！

       善于总结，我们就能提高，善于发现，我们就有机会！
Tags - , , ]]> http://zhoujin.com/post/104/ <![CDATA[学会放弃]]> chirs <> Sun, 22 Jun 2008 07:27:46 +0000 http://zhoujin.com/post/104/ 　一如感情，爱的时候伤的遍体鳞伤，不一定就会刻苦铭心，有些事情＂只可远视而不可近瞧的＂！
　　学会放弃，生活就会比较容易．
　　　学会放弃，在落泪以前转身离去．
　　　　学会放弃，在天黑以前携阳归去．
　　　　．．．．．．
Tags - ]]> http://zhoujin.com/post/92/ <![CDATA[n＋1统计解决办法]]> chirs <> Thu, 19 Jun 2008 18:32:13 +0000 http://zhoujin.com/post/92/
      首先否定一种做法：hql：FROM Department department。然后针对每个department，去做department.getEmployees().size()。这样不仅会发送n＋1条SQL，而且性能太低。

      我们肯定希望采用一句HQL解决问题，但是此时问题来了，当你试图做SELECT department, count(employee.id) FROM .....这样的HQL时，在Java端，发现没有一个合适的对象可以映射。

      从OO的角度，其实可以在Department这个类中加一个employeeSize来表示这种业务场景。但是好像Hibernate无法去做类似的映射。而iBatis在这个方面却灵活的多。

      可以用hql一句话写：
select new DepartmentView(d.poin,count(e.poin)) from Department d inner join d.employeeSet group by d.poin.

Tags - , ]]> http://zhoujin.com/post/94/ <![CDATA[Spring配置初始化ApplicationContext]]> chirs <> Wed, 18 Jun 2008 07:16:42 +0000 http://zhoujin.com/post/94/
xml 代码
<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn"/>  
    <set-property property="contextConfigLocation" value="/WEB-INF/applicationContext.xml"/>  
</plug-in>

这种方式如果没有配置contextConfigLocation的值，则会自动加载xx-servlet.xml.

xx的值是和web.xml里的配置org.apache.struts.action.ActionServlet的servlet-name的值一样

如下：xx的值也就是 action,所以会自动加载action-servlet.xml

xml 代码
<servlet>
    <servlet-name>action</servlet-name>
    <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
    <load-on-startup >1</load-on-startup >
</servlet>  
<servlet-mapping>
    <servlet-name>action</servlet-name>
    <url-pattern>*.do</url-pattern>
</servlet-mapping>

如果sturts-config.xml里配置了contextConfigLocation的值，那么就不会自动加载xx-servlet.xml了，而只会加载contextConfigLocation所指定的xml.

2. 第2种方式

在web.xml里配置Listener

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

如果在web.xml里给该Listener指定要加载的xml,如：
<context-param>  
        <param-name>contextConfigLocationparam-name>  
        <param-value>classpath*:spring/*.xmlparam-value>  
</context-param>
  

则会去加载相应的xml,而不会去加载/WEB-INF/下的applicationContext.xml。。但是，如果没有指定的话，默认会去/WEB-INF/下加载applicationContext.xml。

3. 第三种方式：ContextLoaderServlet

xml 代码
<servlet>
        <servlet-name>context</servlet-name>    
        <servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>    
        <load-on-startup>1</load-on-startup>
</servlet>
  

这种方式和第二种Listener方式一样，唯一的区别就是用Listener方式初始化ApplicationContext，可以和用第一种方式（struts-config.xml里 plugin方式）同时存在，而ContextLoaderServlet则不可以和第一种方式同时存在

总结：
ContextLoaderServlet已经不推荐用了，它只是为了兼容低版本的servlet.jar才用的。

总的来说:Listerner要比Servlet更好一些，而且Listerner监听应用的启动和结束，而Servlet启动要稍微延迟一些。
Tags - , , , ]]> http://zhoujin.com/post/107/ <![CDATA[哈佛的幸福课]]> chirs <> Tue, 17 Jun 2008 10:29:41 +0000 http://zhoujin.com/post/107/ 　　本－沙哈尔自称是一个害羞、内向的人。"在哈佛，我第一次教授积极心理学课时，只有8个学生报名，其中，还有2人中途退课。第二次，我有近400名学生。到了第三次，当学生数目达到850人时，上课更多的是让我感到紧张和不安。特别是当学生的家长、爷爷奶奶和那些媒体的朋友们，开始出现在我课堂上的时侯。"　
　　本－沙哈尔成了"哈佛红人"。校刊和《波士顿环球报》等多家媒体，报道了积极心理学课在哈佛火爆的情景。　
"幸福课"为何会在哈佛大受欢迎？

一、我们越来越富有，可为什么还是不开心呢?
　　"我曾不快乐了30年。"本－沙哈尔这样说自己。　
　　他也是哈佛的毕业生，从本科读到博士。在哈佛，作为三名优秀生之一，他曾被派往剑桥进行交换学习。他还是个一流的运动员，在社团活动方面也很活跃。但这些并没有让他感到持久的幸福。他坦言，自己的内心并不快乐。　
　　"最初，引起我对积极心理学兴趣的是我的经历。我开始意识到，内在的东西比外在的东西，对幸福感更重要。通过研究这门学科，我受益匪浅。我想把我所学的东西和别人一起分享，于是，我决定做一名教师。"　
　　在本－沙哈尔第二次开设"幸福课"的2004年，哈佛校报上有一篇报道：《学校面临心理健康危机》，标题下的导语说：在过去的一年，绝大多数学生感到过沮丧和消沉。文章引述了一位学校舍区辅导员写给舍区主管的信。　
　　"我快覆没了。"这位辅导员写道。在他分管的舍区内，有20个学生出现了心理问题。一个学生因为严重焦虑而无法完成学期作业；另一个学生因为精神崩溃而错过三门考试……舍区主管把这封信转给了哈佛校长，并强调该舍区的问题并不是特例。　
　　一位曾患严重焦虑和情绪紊乱的哈佛毕业生说：大多数哈佛学生还没意识到，即使那些表面看来很积极、很棒的学生，也很有可能正在被心理疾病折磨着，即使你是他最要好的朋友，也未必意识到他有心理问题。　
　　"在内心深处，我经常觉得自己会窒息或者死去。"这名学生说。她时常不明原由地哭泣，总要把自己关起来才能睡觉。她看过几个心理医生，试过6种药物，休学两个月，来应付自己的心理问题。"我是一个成绩优异的哈佛精神病患者。"她这样描述自己。　
　　有个名叫玛丽亚的哈佛女生，在宿舍内自杀，年仅19岁。她的室友回忆说：就在自杀前一晚，玛丽亚和班里同学谈论天气时，还表现得十分开心的样子。"她看起来很好。她在听音乐，调子好像还很欢快。"　
　　哈佛一项持续6个月的调查发现，学生正面临普遍的心理健康危机。调查称：过去的一年中，有80％的哈佛学生，至少有过一次感到非常沮丧、消沉。47％的学生，至少有过一次因为太沮丧而无法正常做事，10％的学生称他们曾经考虑过自杀……　
　　"我们越来越富有，可为什么还是不开心呢？"这是令许多美国人深感困惑的问题。据统计，在美国，抑郁症的患病率，比起20世纪60年代高出10倍，抑郁症的发病年龄，也从上世纪60年代的29.5岁下降到今天的14.5岁。而许多国家，也正在步美国后尘。1957年，英国有52％的人，表示自己感到非常幸福，而到了2005年，只剩下36％。但在这段时间里，英国国民的平均收入却提高了3倍。

二、我们来到这个世上，到底追求什么才是最重要的？　
　　本－沙哈尔坚定地认为：幸福感是衡量人生的唯一标准，是所有目标的最终目标。　
　　"人们衡量商业成就时，标准是钱。用钱去评估资产和债务、利润和亏损，所有与钱无关的都不会被考虑进去，金钱是最高的财富。但是我认为，人生与商业一样，也有盈利和亏损。　
　　"具体地说，在看待自己的生命时，可以把负面情绪当作支出，把正面情绪当作收入。当正面情绪多于负面情绪时，我们在幸福这一'至高财富'上就盈利了。　
　　长期的抑郁，可以被看成是一种'情感破产'。整个社会，也有可能面临这种问题，如果个体的问题不断增长，焦虑和压力的问题越来越多，社会就正在走向幸福的'大萧条'。"　
　　一项有关"幸福"的研究表明，人的幸福感主要取决3个因素："遗传基因、与幸福有关的环境因素以及能够帮助我们获得幸福的行动。而积极心理学，可以帮助人们活得更快乐、更充实。幸福，是可以通过学习和练习获得的。"　
　　本－沙哈尔说："我知道它是可行的，因为，它已深深地帮助了我。"　
　　我们的很多课，都在教学生如何更好地思考、更好地阅读、更好地写作，可是为什么就不该有人教学生更好地生活呢？把艰深的积极心理学学术成果简约化、实用化，教学生懂得自我帮助，这是本－沙哈尔开设"幸福课"的初衷。

三、幸福，应该是快乐与意义的结合
　　让本－沙哈尔对幸福的理解，发生根本转变的起因，是他早年的一次重要经历。　
　　16岁那年，在以色列长大的本－沙哈尔，获得了全国壁球赛的冠军。在长达5年的训练中，空虚感如影相伴，他一直觉得生命中缺少了什么。虽为此闷闷不乐，但他仍坚信：无论身体或心理都要坚强，才能最终取胜；而胜利，一定会带来充实感，也能让自己最终幸福。　
　　终于，本－沙哈尔如愿以偿，夺冠后的他欣喜若狂，和家人、朋友举行了隆重的庆贺。那时，他对自己的理念更加深信不疑：成功可以带来快乐，过去所受的种种苦痛，都是值得的。　
　　"可就在那天晚上，睡前我坐在床上，试着再回味一下无限的快感。可是突然间，那种胜利的感觉，那种梦想成真的喜悦，所有的快乐，都消失得无影无踪。我的内心，忽然又变得很空虚，只有迷惘和恐惧。泪水涌出，不再是喜极而泣，而是伤心难过。在如此顺意的情况下，尚不能感到幸福的话，那我将到何处，去寻找我人生的幸福？"　
　　他极力让自己镇定，并告诉自己这只是暂时的神经过敏。但在接下来的日子里，他仍没有找回快乐；相反，内心的空虚感越来越重。慢慢地他发现：胜利，并没为他带来任何幸福，他所依赖的逻辑彻底被打破。"从那时起，我开始对一个问题非常着迷：如何才能得到真正的幸福？"　
　　本－沙哈尔注意观察周围的人，谁看起来幸福，他就向谁请教。他读有关幸福的书，从亚里士多德到孔子，从古代哲学到现代心理学，从学术研究到自助书籍等等。最后他决定去大学主修哲学和心理学。　
　　他的幸福观，逐渐清晰起来：幸福，应该是快乐与意义的结合。　
　　"一个幸福的人，必须有一个明确的、可以带来快乐和意义的目标，然后努力地去追求。真正快乐的人，会在自己觉得有意义的生活方式里，享受它的点点滴滴。"　
　　本－沙哈尔竟然从汉堡里，总结出了4种人生模式。　
　　当年，为了准备重要赛事，除了苦练外，他须严格节制饮食。开赛前一个月，只能吃最瘦的肉类，全麦的碳水化合物，以及新鲜蔬菜和水果。他曾暗中发誓，一旦赛事完了，一定要大吃两天"垃圾食品"。比赛一结束，他干的第一件事，就是奔到自己喜爱的汉堡店，一口气买下4只汉堡。当他急不可待地撕开纸包，把汉堡放在嘴边的刹那，却停住了。因为他意识到，上个月，因为健康的饮食，自己体能充沛。如果享受了眼前汉堡的美味，很可能会后悔，并影响自己的健康。望着眼前的汉堡，他突然发现，它们每一种都有自己独特的风味，可以说，代表着4种不同的人生模式。　
　　第一种汉堡，就是他最先抓起的那只，口味诱人，但却是标准的"垃圾食品"。吃它等于是享受眼前的快乐，但同时也埋下未来的痛苦。用它比喻人生，就是及时享乐，出卖未来幸福的人生，即"享乐主义型"；
      第二种汉堡，口味很差，里边全是蔬菜和有机食物，吃了可以使人日后更健康，但会吃得很痛苦。牺牲眼前的幸福，为的是追求未来的目标，他称之为"忙碌奔波型"；
      第三种汉堡，是最糟糕的，既不美味，吃了还会影响日后的健康。与此相似的人，对生活丧失了希望和追求，既不享受眼前的事物，也不对未来抱期许，是"虚无主义型"；会不会还有一种汉堡，又好吃，又健康呢？
      第四种"幸福型"汉堡。一个幸福的人，是即能享受当下所做的事，又可以获得更美满的未来。　
　　不幸的是，据本－沙哈尔观察，现实生活中的大部分人，都属于"忙碌奔波型"。

四、人们习惯性地去关注下一个目标，而常常忽略了眼前的事情。
　　本－沙哈尔经常讲"蒂姆的故事"。在这个故事里，晃动着许多人熟悉的影子。　
　　蒂姆小时候，是个无忧无虑的孩子。但自打上小学那天起，他忙碌奔波的人生就开始了。父母和老师总告诫他，上学的目的，就是取得好成绩，这样长大后，才能找到好工作。没人告诉他，学校，可以是个获得快乐的地方，学习，可以是件令人开心的事。因为害怕考试考不好，担心作文写错字，蒂姆背负着焦虑和压力。他天天盼望的，就是下课和放学。他的精神寄托就是每年的假期。　
　　渐渐地，蒂姆接受了大人的价值观。虽然他不喜欢学校，但还是努力学习。成绩好时，父母和老师都夸他，同学们也羡慕他。到高中时，蒂姆已对此深信不疑：牺牲现在，是为了换取未来的幸福；没有痛苦，就不会有收获。当压力大到无法承受时，他安慰自己：一旦上了大学，一切就会变好。　
　　收到大学录取通知书时，蒂姆激动得落泪。他长长舒了一口气：现在，可以开心地生活了。但没过几天，那熟悉的焦虑又卷土重来。他担心在和大学同学的竞争中，自己不能取胜。如果不能打败他们，自己将来就找不到好工作。　
　　大学4年，蒂姆依旧奔忙着，极力为自己的履历表增光添彩。他成立学生社团、做义工，参加多种运动项目，小心翼翼地选修课程，但这一切完全不是出于兴趣，而是这些科目，可以保证他获得好成绩。　
　　大四那年，蒂姆被一家著名的公司录用了。他又一次兴奋地告诉自己，这回终于可以享受生活了。可他很快就感觉到，这份每周需要工作84小时的高薪工作，充满压力。他又说服自己：没关系，这样干，今后的职位才会更稳固，才能更快地升职。当然，他也有开心的时刻，在加薪、拿到奖金或升职时。但这些满足感，很快就消退了。　
　　经过多年的打拼，蒂姆成了公司合伙人。他曾多么渴望这一天。可是，当这一天真的到来时，他却没觉得多快乐。蒂姆拥有了豪宅、名牌跑车。他的存款一辈子都用不完。　
　　他被身边的人认定为成功的典型。朋友拿他当偶像，来教育自己的小孩。可是蒂姆呢，由于无法在盲目的追求中找到幸福，他干脆把注意力集中在了眼下，用酗酒、吸毒来麻醉自己。他尽可能延长假期，在阳光下的海滩一呆就是几个钟头，享受着毫无目的的人生，再也不去担心明天的事。起初，他快活极了，但很快，他又感到了厌倦。　
　　做"忙碌奔波型"并不快乐，做"享乐主义型"也不开心，因为找不到出路，蒂姆决定向命运投降，听天由命。但他的孩子们怎么办呢？他该引导他们过怎样的一种人生呢？蒂姆为此深感痛苦。　
　　为什么当今社会有那么多"忙碌奔波型"的人呢？本－沙哈尔这样解释：因为人们常常被"幸福的假象"所蒙蔽。　
　　我们所处的社会环境和文化背景是这样的：假如孩子成绩全优，家长就会给奖励；如果员工工作出色，老板就会发给奖金。人们习惯性地去关注下一个目标，而常常忽略了眼前的事情，最后，导致终生的盲目追求。　
　　然而一旦目标达成后，人们常把放松的心情，解释为幸福。好像事情越难做，成功后的幸福感就越强。不可否认，这种解脱，让我们感到真实的快乐，但它绝不等同于"幸福"。它只是"幸福的假象"。　
　　这就好比一个人头痛好了之后，他会为头不痛而高兴，这是由于这种喜悦，来自于痛苦的前因。"忙碌奔波型"的人，错误地认为成功就是幸福，坚信目标实现后的放松和解脱，就是幸福。因此，他们不停地从一个目标奔向另一个目标。　
　　在本－沙哈尔看来，寻找真正能让自己快乐而有意义的目标，才是获得幸福的关键。

五、他们把物质与财富，放在了快乐和意义之上
　　在课堂上，本－沙哈尔不断地向听讲者发问：　
　　我们可以不停地追问"为什么"，来反思自己所追求的东西：可以是大房子、升职或任何其他的目标。看看要问多少个"为什么"，才能落到"幸福"的追求上？问问自己，我做的事情，对我有意义吗？它们给我带来了乐趣吗？我的内心，是否鼓励我去做不同的尝试？是不是在提醒我，需要彻底改变目前的生活？　
　　本－沙哈尔的哲学老师在他毕业时，给了他一点忠告："生命很短暂，在选择道路前，先确定自己能做的事。其中，做那些你想做的。然后再细化，找出你真正想做的。最后，对于那些真正、真正想做的事，付诸行动。"　
　　本－沙哈尔也这样教他的学生，如何寻找能发挥自己优势和热情的工作。　
      用以下3个关键问题，先来问问自己：
      一，什么带给我意义？
      二，什么带给我快乐？
      三，我的优势是什么？
      并且要注意顺序。然后看一下答案，找出这其中的交集点，那个工作，就是最能使你感到幸福的工作了。　
      10多年前，本－沙哈尔遇到过一个年轻人。他是一名律师，在纽约一家知名公司上班，并即将成为合伙人。坐在他的高级公寓里，中央公园的美景一览无余。年轻人非常努力地工作，一周至少干60个小时。早上，他挣扎着起床，把自己拖到办公室，与客户和同事的会议、法律报告与合约事项，占据了他的每一天。当本－沙哈尔问他，在一个理想世界里还想做什么时，这名律师说，最想去一家画廊工作。　
　　"难道说，现实世界里找不到画廊的工作吗？"年轻人说不是的。但如果在画廊工作，收入会少许多，生活水平也会下降。他虽对律师楼很反感，但觉得没其他选择。　
　　因为被一个不喜欢的工作所捆绑，所以他每天并不开心。在美国，有50％的人对自己的工作不甚满意。但本－沙哈尔认为，这些人之所以不开心，并不是因为他们别无选择，而是他们的决定，让他们不开心。因为他们把物质与财富，放在了快乐和意义之上。　
　　"金钱和幸福，都是生存的必需品，并非互相排斥。"他说。　
　　他进一步说，通常在越感兴趣的事情里，人就越能发挥自己的天赋，越能做得持久。人一旦有了热情，不但动机坚定，连做事效率也会提高。举例讲，一个热爱学习的学生，可以在学习中享受创造的愉悦，而这快乐的成果，还可以帮他取得好成绩，助其获得未来的幸福。在亲密关系中也一样，两个人共享着爱情的美好，并促进彼此的成长和发展。　
　　许多研究表明，一个幸福的人，在生活的各个层面上都会很成功，包括婚姻、友谊、收入、工作表现以及健康。幸福与成功，存在强烈的相互作用，无论是工作上还是感情上的成功，可以带来幸福；而幸福本身，也能带来更多的成功。　
　　本－沙哈尔总结出这样3种工作境界：赚钱谋生、事业、使命感。　
　　如果只把工作当成任务和赚钱的手段，就没有任何的个人实现。这样每天去上班，只是必须而不是想去，他所期盼的，除了薪水，就是节假日了；把工作当事业的人，除了注重财富的积累外，还会关注事业的发展，如权力和声望等。他们会关心下一个升职的机会，期望从副教授到终身教授、从教师到校长、从职员到主管、从编辑到总编辑；假如，把工作当成使命，那工作本身就是目标了。薪水、职位固然重要，但他们工作，是因为他们想要做这份工作，动力源自内心。工作是一种恩典，而不是为人打工。他们对工作充满热情，在工作中自我实现，获得充实感。他们的目标，正是自我和谐的目标。　
　　有一项研究，是针对医院清洁工的。一组人觉得自己的清洁工作很无聊，没啥意义；但另一组人，觉得很有意义，做得很投入。他们与护士、病人以及家属交谈，想办法让医院员工、病人舒适。他们看待工作的角度更高，并在其中找到了意义：我不仅仅是个倒垃圾和洗衣服的人，正是我的工作，让医院正常运转，帮助病人更快地康复。　
　　就像第二组人，由于在日常工作中找到了使命感，因而从中也得到了更多的意义和快乐，他们与服务对象的关系，也不再是简单的金钱关系。有时候，人们并没有换工作，或改变工作环境，他们所做的，只是赋予了工作本身更多的意义，从中发现乐趣，因而也提升了幸福感。　
　　可以想像，一个因为家长的压力而学法律的人，是无法在其中找到长久快乐的；相反，如果是基于对法律的热爱而成为律师的话，那他在维护公义的同时，也会觉得很幸福。　
　　"一个在工作中找到意义与快乐的投资家，一个出于正确动机的商人，绝对要比一个心不在焉的和尚，高尚和有意义得多。"本－沙哈尔笃定地说。　
　　不同的人，会在不同的事里找到意义。如创业、当义工、抚养子女、行医、甚至是打家具。重要的是，选择目标时，必须确定它符合自己的价值观、爱好，符合自己内心的愿望，而不是为了满足社会标准，或是迎合他人的期待。"真我的呼唤"，就是使命感。　
　　"那真是神奇的时刻。"本－沙哈尔用一段话，描述这种美妙的体验：我甚至形成了一种迷信，世上确实有看不见的力量在帮我。只要你追随自己的天赋和内心，你就会发现，生命的轨迹原已存在，正期待你的光临，你所经历的，正是你应拥有的生活。当你能够感觉到自己正行走在命运的轨道上，你会发现，周围的人，开始源源不断地带给你新的机会。　
　　"在追求有意义而又快乐的目标时，我们不再是消磨光阴，而是在让时间，闪闪发光。"

六、我也有不快乐的时刻，因为我们是人　
　　一天，在哈佛的食堂，有个学生走到本－沙哈尔面前，问他：你就是那个教人如何快活的老师吧。学生接着又说：你要小心，我的室友选了你的课，如果哪天我发现你并不快乐，我就要告诉他，别再上你的课。本－沙哈尔看着这个学生，笑着道：没关系，我现在就可以告诉你，我也有不快乐的时刻，因为我们是人。　
　　"总有人问我，你能帮我消除痛苦吗？可是为什么要用这种态度来对待痛苦。痛苦，是我们的人生经验，会让我们从中学到很多。人生的成长和飞跃，经常发生在你觉得非常痛苦的时刻。"　
　　漫漫人生，每个人都不可避免地会面临悲伤的时刻，比如经历失败或失去，但我们依然可以活得幸福。事实上，期盼无时无刻的快乐，只会带来失望和不满，并最终导致负面情绪的产生。　
　　一个幸福的人，也会有情绪上的起伏，但整体上，能保持一种积极的人生态度。他经常被积极的情绪推动着，如欢乐和爱；很少被愤怒或内疚，这些负面情绪所控制。快乐是常态，而痛苦都是小插曲。　
　　刚开始讲"幸福课"时，本－沙哈尔很想扮演一个无所不知、幽默的人，一个完美的导师，为此，他特地跑到喜剧演员培训班学习。但他不是那种能开激烈的玩笑，做夸张表演的人。无论怎么学，他也达不到想要的戏剧效果。　
　　想让自己当一个完美的老师，他发现这样即害了自己，也害了学生。"每次都很紧张，怕被发现面具下真实的样子，结果把自己搞得很累。这样不仅害了我自己，也伤害了学生，等于给学生树立了一个'完人'典型，告诉学生走一条永远走不通、错误的路。打开自己，袒露真实的人性，会唤起学生真实的人性。在学生面前做一个自然的人，反而会更受尊重。"　
　　本－沙哈尔希望他的学生，学会接受自己，不要忽略自己所拥有的独特性；要摆脱"完美主义"，要"学会失败"。　
　　为了更好地记住"幸福课"的要点，本－沙哈尔还为学生简化出10条小贴士：　
　　1．遵从你内心的热情。选择对你有意义并且能让你快乐的课，不要只是为了轻松地拿一个A而选课，或选你朋友上的课，或是别人认为你应该上的课。　
　　2．多和朋友们在一起。不要被日常工作缠身，亲密的人际关系，是你幸福感的信号，最有可能为你带来幸福。　
　　3．学会失败。成功没有捷径，历史上有成就的人，总是敢于行动，也会经常失败。不要让对失败的恐惧，绊住你尝试新事物的脚步。　
　　4．接受自己全然为人。失望、烦乱、悲伤是人性的一部分。接纳这些，并把它们当成自然之事，允许自己偶尔的失落和伤感。然后问问自己，能做些什么来让自己感觉好过一点。　
　　5．简化生活。更多并不总代表更好，好事多了，也不一定有利。你选了太多的课吗？参加了太多的活动吗？应求精而不在多。　
　　6．有规律地锻炼。体育运动是你生活中最重要的事情之一。每周只要3次，每次只要30分钟，就能大大改善你的身心健康。　
　　7．睡眠。虽然有时"熬通宵"是不可避免的，但每天7到9小时的睡眠是一笔非常棒的投资。这样，在醒着的时候，你会更有效率、更有创造力，也会更开心。　
　　8．慷慨。现在，你的钱包里可能没有太多钱，你也没有太多时间。但这并不意味着你无法助人。"给予"和"接受"是一件事的两个面。当我们帮助别人时，我们也在帮助自己；当我们帮助自己时，也是在间接地帮助他人。　
　　9．勇敢。勇气并不是不恐惧，而是心怀恐惧，仍依然向前。　
　　10。表达感激。生活中，不要把你的家人、朋友、健康、教育等这一切当成理所当然的。它们都是你回味无穷的礼物。记录他人的点滴恩惠，始终保持感恩之心。每天或至少每周一次，请你把它们记下来。　
　　"上这门课，真是一种享受。它非常有趣，而且值得学生学习。"一位读经济学专业的本科生，在发给我们的邮件中写道。她还说：事实上，这门课并不会帮我拿攻读学位的学分。但比起其它课程，我更喜欢做这门课的作业。　
　　在哈佛的校报上，也留下学生们的反馈意见：　
　　"他教心理学，同其他心理学老师有很大的不同。他试图让你把这些理念，应用到自己的生活中去。""我从记'感恩簿'中收获最大，在那里，我每天写下我充满感激的事情。""上这门课之前，听到'冥想'这个词，我会不以为然。但是现在，我惊奇地发现，它真的让我在接下来的几个小时里，放松了。""我认识的每个上过这门课的人都说，这是他们在哈佛上过的最好的课。一位和我要好的女生说，它改变了她的生命，给了她一种看问题的不同视角，对幸福的理解，也改变了。"　
　　甚至助教们也说，自打跟本－沙哈尔教授"幸福课"以来，一年中，身体出奇得好，心情也爽多了。"我改善了我的饮食、睡眠、人际关系，还有人生的方向感。这些对我来说，都是很重要的东西。"另一位助教称，这门课的出勤率，平均在95％以上。"它的奇妙之处在于，当学生们离开教室的时候，都迈着春天一样的步子。"　
　　2006年2月，哈佛出了件大事，校长萨默斯为自己的惊人之语"女人先天不如男"，付出了"下课"的代价。即将去职的萨默斯闷闷不乐，他的好友找到本－沙哈尔，讨要如何让校长快乐起来的秘笈，本－沙哈尔慷慨支招。　
　　首先，他现在可能很烦乱、失落、难过，这些都属正常，因为他也是人。去大胆地经历他现在正经历着的任何事，并且自然地接受下来。　
　　第二，建议萨默斯本人，阅读一下哈佛积极心理学教授丹尼尔·吉尔波特的书，书中说：人类有非凡的克服令情绪失落事件的能力。事情并没有像他最初看起来的那么糟，即使是被逐出世界顶级大学的校长之位。　
　　第三，他可以仔细反省一下作为哈佛校长的经历，回忆自己任期内的巅峰时刻，并用他所学到的东西，去寻找新的机会和用武之地。　
　　假如上述办法仍不奏效的话，本－沙哈尔支了最后一招：我可以在我的课堂上，留下一个座位，校长先生
Tags - , ]]> http://zhoujin.com/post/84/ <![CDATA[Hibernate-核心接口]]> chirs <> Mon, 16 Jun 2008 03:06:31 +0000 http://zhoujin.com/post/84/       Session 接口对于Hibernate 开发人员来说是一个最重要的接口。然而在Hibernate 中，实例化的Session是一个轻量级的类，创建和销毁它都不会占用很多资源。这在实际项目中确实很重要，因为在客户程序中，可能会不断地创建以及销毁Session 对象，如果Session 的开销太大，会给系统带来不良影响。但值得注意的是Session 对象是非线程安全的，因此在你的设计中，最好是一个线程只创建一个Session对象。
      在Hibernate 的设计者的头脑中，他们将session看作介于数据连接与事务管理一种中间接口。我们可以将session想象成一个持久对象的缓冲区，Hibernate能检测到这些持久对象的改变，并及时刷新数据库。我们有时也称Session是一个持久层管理器，因为它包含这一些持久层相关的操作，诸如存储持久对象至数据库，以及从数据库从获得它们。请注意，Hibernate 的session不同于JSP应用中的HttpSession。当我们使用session这个术语时，我们指的是Hibernate 中的session，而我们以后会将HttpSesion 对象称为用户session。

SessionFactory 接口:
      这里用到了一个设计模式――工厂模式，用户程序从工厂类SessionFactory中取得Session 的实例。
      令你感到奇怪的是SessionFactory并不是轻量级的！实际上它的设计者的意图是让它能在整个应用中共享。典型地来说，一个项目通常只需要一个SessionFactory就够了，但是当你的项目要操作多个数据库时，那你必须为每个数据库指定一个SessionFactory。
      SessionFactory在Hibernate中实际起到了一个缓冲区的作用，它缓冲了Hibernate自动生成的SQL语句和一些其它的映射数据，还缓冲了一些将来有可能重复利用的数据。

Configuration 接口:
      Configuration 接口的作用是对Hibernate 进行配置，以及对它进行启动。在Hibernate 的启动过程中，Configuration 类的实例首先定位映射文档的位置，读取这些配置，然后创建一个SessionFactory对象。虽然Configuration 接口在整个Hibernate 项目中只扮演着一个很小的角色，但它是启动hibernate 时你所遇到的每一个对象。

Transaction 接口:
      Transaction 接口是一个可选的API，你可以选择不使用这个接口，取而代之的是Hibernate 的设计者自己写的底层事务处理代码。 Transaction 接口是对实际事务实现的一个抽象，这些实现包括JDBC的事务、JTA 中的UserTransaction、甚至可以是CORBA 事务。之所以这样设计是能让开发者能够使用一个统一事务的操作界面，使得自己的项目可以在不同的环境和容器之间方便地移值。

Query 和Criteria接口
      Query接口让你方便地对数据库及持久对象进行查询，它可以有两种表达方式：HQL语言或本地数据库的SQL语句。Query经常被用来绑定查询参数、限制查询记录数量，并最终执行查询操作。Criteria接口与Query接口非常类似，它允许你创建并执行面向对象的标准化查询。值得注意的是Query接口也是轻量级的，它不能在Session之外使用。

Callback 接口:
      当一些有用的事件发生时――例如持久对象的载入、存储、删除时，Callback 接口会通知
Hibernate去接收一个通知消息。一般而言，Callback接口在用户程序中并不是必须的，但你要在你
的项目中创建审计日志时，你可能会用到它。

策略接口:
      Hibernate与某些其它开源软件不同的还有一点――高度的可扩展性，这通过它的内置策略机制来实现。当你感觉到Hibernate 的某些功能不足，或者有某些缺陷时，你可以开发一个自己的策略来替换它，而你所要做的仅仅只是继承它的某个策略接口，然后实现你的新策略就可以了，以下是
它的策略接口：
· 主键的生成 (IdentifierGenerator 接口)
· 本地SQL语言支持 (Dialect 抽象类)
· 缓冲机制 (Cache 和CacheProvider 接口)
· JDBC 连接管理 (ConnectionProvider接口)
· 事务管理 (TransactionFactory, Transaction, 和 TransactionManagerLookup 接口)
· ORM 策略 (ClassPersister 接口)
· 属性访问策略 (PropertyAccessor 接口)
· 代理对象的创建 (ProxyFactory接口)
Hibernate为以上所列的机制分别创建了一个缺省的实现，因此如果你只是要增强它的某个策略的功能的话，只需简单地继承这个类就可以了，没有必要从头开始写代码。
Tags - , ]]> http://zhoujin.com/post/106/ <![CDATA[Servlet和Filter的url匹配以及url-pattern详解]]> chirs <> Fri, 13 Jun 2008 07:56:40 +0000 http://zhoujin.com/post/106/
      一，servlet容器对url的匹配过程：
　   当一个请求发送到servlet容器的时候，容器先会将请求的url减去当前应用上下文的路径作为servlet的映射url，比如我访问的是http://localhost/test/aaa.html，我的应用上下文是test，容器会将http://localhost/test去掉，剩下的/aaa.html部分拿来做servlet的映射匹配。这个映射匹配过程是有顺序的，而且当有一个servlet匹配成功以后，就不会去理会剩下的servlet了（filter不同，后文会提到）。其匹配规则和顺序如下：
引用
　　1. 精确路径匹配。例子：比如servletA 的url-pattern为 /test，servletB的url-pattern为 /* ，这个时候，如果我访问的url为http://localhost/test ，这个时候容器就会先 进行精确路径匹配，发现/test正好被servletA精确匹配，那么就去调用servletA，也不会去理会其他的servlet了。

      2.最长路径匹配。例子：servletA的url-pattern为/test/*，而servletB的url-pattern为/test/a/*，此时访问http://localhost/test/a时，容器会选择路径最长的servlet来匹配，也就是这里的servletB。

      3.扩展匹配，如果url最后一段包含扩展，容器将会根据扩展选择合适的servlet。例子：servletA的url-pattern：*.action

      4.如果前面三条规则都没有找到一个servlet，容器会根据url选择对应的请求资源。如果应用定义了一个default servlet，则容器会将请求丢给default servlet（什么是default servlet？后面会讲）。

      根据这个规则表，就能很清楚的知道servlet的匹配过程，所以定义servlet的时候也要考虑url-pattern的写法，以免出错。

      对于filter，不会像servlet那样只匹配一个servlet，因为filter的集合是一个链，所以只会有处理的顺序不同，而不会出现只选择一个filter。Filter的处理顺序和filter-mapping在web.xml中定义的顺序相同。
      二，url-pattern详解
      在web.xml文件中，以下语法用于定义映射：
引用
1.以”/’开头和以”/*”结尾的是用来做路径映射的。
2.以前缀”*.”开头的是用来做扩展映射的。
3.“/” 是用来定义default servlet映射的。
4.剩下的都是用来定义详细映射的。比如： /aa/bb/cc.action

     所以，为什么定义”/*.action”这样一个看起来很正常的匹配会错？因为这个匹配即属于路径映射，也属于扩展映射，导致容器无法判断。

    【参考内容】Java  Servlet 2.4 Specification
Tags - , , , , ]]> http://zhoujin.com/post/85/ <![CDATA[[转]由毕设答辩看国内高等教育——出离愤怒！]]> chirs <> Fri, 13 Jun 2008 03:12:57 +0000 http://zhoujin.com/post/85/ 回来后立马把QQ签名改成了：“所谓论文，论众家之言也。打磨创新，统一模式，归于中庸！”算是对学院本科毕设论文与答辩的一种反讽，也确是一种真实而无奈的写照。
任何有价值的个人见解都被否认的一文不值或搪塞为没有论据与先例。答辩过程中所谓“专家”的老师们，发表最多有建设性的见解就是论文格式不好，需要重新排版，或是按一般写作路程，第三、四章要结合系统实例，给出设计与代码。下面列举些经典的答辩问答如下：

专家：“论文不要中英文间杂，比如说Ruby on Rails，直接写Ruby在Rails中的应用就好了。”

专家：“你这个重构示例有什么量化指标吗？比如重构后代码行数减少了多少，怎么证明你的重构就更好？”
学生：“重构主要是改善代码质量，使其更具可读性与易修改性，借由我文中谈到的具体手段找出代码中存在的坏味道，并逐步优化设计。因此，很难说行数越少就是越好的重构。”
专家：“那你应该设计一个重构框架，让别人能有拿来就用的重构组件拿......”

专家：“你文中提到的参考文献是最优的解决方案，何以见得？”
学生：“这篇文章是Oxford一个研究院在2007年8月公开发布的一个算法，被业界公认为现有的最优解。”
专家：“07年8月到现在也快一年了，你怎么就知道这中间没有更好的研究成果发布？所以永远不要用最优这类绝对的说法！”

专家：“你这个论文写的比较边缘化，谈项目管理为什么不结合实例给出一个管理模型，并给出测量数据，说明这个模型到底是好是坏？”
学生：“我在绪论中就说了,在软件开发中，每个人都使用他自己的模式来解析他在项目中的经验，每个人也往往成为这种常见错误的受害者，因此按进度做出成功的软件是世界上最困难的事情之一，不能完全依赖于公式，每一个软件都有其独特性，在软件开发的任何时刻，都需要特别的付出才行。这也是全文团队自管理的提出先决。所以我无法给出唯一模型。”
专家：“你没明白我说的，我觉得你这篇文章不符合论文规范，没有写明应该怎么做，怎么验证，谈的都是你个人的见解。”

专家：“论文中不要出现全文、是什么等词，那样会显得很没水平。用词既不要文学化也不要通俗化，写的要有深度，让别人一下子看不懂、不能理解。”

所以，由于专家们根本没时间细看和理解你的论文，任何有新意的论点都是边缘化、危险的信号，因为那样根本就不能被一知半解，且以己之见度他人之心的专家们认可。最好的论文，就是依照专家们的指导和理解，规规矩矩的把专家看问题的角度和论点说清楚，不要加任何自己的创建与理解。同时严格按论文要求排版，写章节大纲，一点儿发挥的余地都不能有。
在我看来，如此的论文评审标准与自明代起沿袭数百年的八股作文无异，都要遵循固定的格式，破题、承题、起讲、入手步步不离，阐述圣人之道，稍作合众之意的评述就是好文。这真是国内高等教育的可悲！无数抄袭、综述之作，只因合乎众意，虽无甚创见却亦无大过，而被导师、专家们网开一面。而我却因为写了些有别传统的个人见解而被评定为“论文边缘化”，需大动干戈，增删五次方，可修为正果，顺利毕业。
想想自己这半年来的经历也确实丧气。原本心高气傲地打算利用在校的最后时间不受约束地为了理想而开发一款产品推出去运营下，因此义无反顾的辞掉了实习与几个工作offer，学期初就回到学校组建团队。最终因大家志向不同，而分道扬镳，项目流产。之后调整心情，专心论文，希望把自己带领团队的经验与体会融入文中，阐述自己对软件开发与团队管理的理解，也算对大学四年软件工程专业学习的诠释。然而一个月没日没夜的奋斗却换来如此结果，既是心有不甘又又无比愤慨。
相比美国的教育，人家一再强调独立与创新，MIT的算法导论第一节课上，Leiserson教授花了20多分钟专门说明课程要求与独立创新的重要。而我们在教学最重要的一环，毕设论文的评定与答辩上确是如此导向，实在令人寒心。
在这里不是因为个人私怨而愤世嫉俗，主要是这过程中有太多的不能理解与看不懂，让人不能不一吐为快。一篇论及软件开发团队管理的文章竟被软件工程专业的老师们一致认为偏离了专业主旨，那您在教学的过程中还安排这么多探讨管理项目的“边缘课程”又是何意？一个个仅扫了眼标题与目录，就敢对自己不曾设计领域而横加批评的专家们，还真以为自己无所不通了吧？那专家的名号也该换换，下次叫您们博古通今的大师好了。
算了，一时愤慨之言，也知道自己多说无益，国内高等教育的风气已然如此，没有选择继续进修硕士就已是自己看破体制现状的英明了，其他原本也没任何再可期望的了。
Tags - , ]]> http://zhoujin.com/post/99/ <![CDATA[命令模式]]> chirs <> Thu, 12 Jun 2008 07:48:21 +0000 http://zhoujin.com/post/99/ 1.接受者角色（相当于厨师）
2.请求者角色(相当于顾客)
3.命令角色
4.具体命令角色
5.客户角色

具体代码如:

package com.pattern.command;  
/**  
*接受者（相当于厨师）  
*/  
public class Receiver {  
      
    public void doReceiverAction(){  
        System.out.println("接受者执行完毕");  
    }  
  
}  

package com.pattern.command;
/**
*接受者（相当于厨师）
*/
public class Receiver {
  
  public void doReceiverAction(){
    System.out.println("接受者执行完毕");
  }

}


package com.pattern.command;  
/**  
*命令角色  
*/  
public interface Command {  
      
    public void execute();  
  
}  

package com.pattern.command;
/**
*命令角色
*/
public interface Command {
  
  public void execute();

}


package com.pattern.command;  
  
/**  
* 具体命令角色,调用接受者执行具体命令。自己不能执行具体命令，所以需要创建一个接受者对象  
*/  
public class CommandImpl implements Command{  
  
    private Receiver receiver;  
    public CommandImpl(Receiver receiver){  
        this.receiver = receiver;  
    }  
    public void execute(){  
        receiver.doReceiverAction();  
    }  
}  

package com.pattern.command;

/**
* 具体命令角色,调用接受者执行具体命令。自己不能执行具体命令，所以需要创建一个接受者对象
*/
public class CommandImpl implements Command{

  private Receiver receiver;
  public CommandImpl(Receiver receiver){
    this.receiver = receiver;
  }
  public void execute(){
    receiver.doReceiverAction();
  }
}


package com.pattern.command;  
/**  
* 请求者角色，需要发出一个命令，所以需要创建一个命令角色的对象.(相当于顾客)  
*/  
public class ReqRole {  
  
    private Command command;  
    public ReqRole(Command command){  
        this.command = command;  
    }  
    public  void  doAction(){  
        command.execute();  
    }  
      
}  

package com.pattern.command;
/**
* 请求者角色，需要发出一个命令，所以需要创建一个命令角色的对象.(相当于顾客)
*/
public class ReqRole {

  private Command command;
  public ReqRole(Command command){
    this.command = command;
  }
  public  void  doAction(){
    command.execute();
  }
  
}

package com.pattern.command;  
/**  
*客户角色  
*/  
public class Test {  
      
    public static void main(String[] args){  
          
        Receiver receiver = new Receiver();//接受者。不和任何对象关联  
          
        Command command = new CommandImpl(receiver);//构建一个命令角色。因为自己不执行任何命令，真正执行命令的是接受者，所以需要传递一个接受者对象  
          
        ReqRole reqRole = new ReqRole(command);//请求角色。因为需要请求一个命令，所以需要接受一个命令角色对象  
      
        reqRole.doAction();  
    }  
      
  
}  

Tags - ]]> http://zhoujin.com/post/98/ <![CDATA[缺省适配器模式和模板方法模式]]> chirs <> Wed, 11 Jun 2008 07:47:39 +0000 http://zhoujin.com/post/98/
缺省适配器模式：当一个接口有很都方法时，所有的实现类都需要实现该接口的所有方法。即使不需要的方法也需要空实现。这时就需要一个适配器类。该适配器类主要是实现该接口的所有方法（一般都空实现）。给真正的子类带来方便。

模板方法模式:父类定义了几个方法。并规定了这几个方法的具体执行流程(哪个方法先执行，哪个方法后执行)，然后其子类实现这些方法。
Tags - , ]]> http://zhoujin.com/post/97/ <![CDATA[组合(Composite)模式]]> chirs <> Tue, 10 Jun 2008 07:46:12 +0000 http://zhoujin.com/post/97/ 1.Component角色
2.Leaf角色
3.Composite角色

Java代码
package com.pattern.composite;  
/**  
* 组件抽象角色  
*  
*/  
public interface Component {  
      
    public void run();  
  
}  

package com.pattern.composite;
/**
* 组件抽象角色
*
*/
public interface Component {
  
  public void run();

}

package com.pattern.composite;  
/**  
* 叶子角色  
*  
*/  
public class Leaf implements Component{  
      
    public void run(){  
        System.out.println(" run invoked...");  
    }  
  
}  

package com.pattern.composite;
/**
* 叶子角色
*
*/
public class Leaf implements Component{
  
  public void run(){
    System.out.println(" run invoked...");
  }

}

package com.pattern.composite;  
  
import java.util.ArrayList;  
import java.util.List;  
/**  
* 组合角色  
* 实现组件角色接口，并且添加，删除的也是组件角色  
*  
* Composite本来可以再包含Leaf和Composite的。而 Leaf和Composite 又都属于 Component，所以增加，删除 的是Component  
*  
* 组合模式主要分为2种  
*  
* 1 透明式  

    添加Component对象的操作定义在Component角色中，这样的话不仅Composite需要实现这些方法，Leaf也需要实现这些方法，  
    而这些方法对于Leaf来说没有任何意义，不过将系统实现统一起来了，因此对用户来说透明（用户无需区分Composite还是Leaf）  
    ，因为这些角色中都具备这些方法。  
      
   2 安全式  

    添加Component对象的操作定义在Composite角色中，这样的话Leaf就无需实现这些方法（因为Leaf本身根本不需要实现这些方法）  
*  
*/  
public class Composite  implements Component{  
      
    List<Component> list = new ArrayList<Component>();  
      
    //添加  
    public void addComponent(Component component){  
        list.add(component);  
    }  
    //删除  
    public void removeComponent(Component component){  
        list.remove(component);  
    }  
      
    //get  
    public List<Component> getAll(){  
        return list;  
    }  
      
    public void run(){  
        for(Component component : list){  
            component.run();  
        }  
    }  
  
}  

package com.pattern.composite;

import java.util.ArrayList;
import java.util.List;
/**
* 组合角色
* 实现组件角色接口，并且添加，删除的也是组件角色
*
* Composite本来可以再包含Leaf和Composite的。而 Leaf和Composite 又都属于 Component，所以增加，删除 的是Component
*
* 组合模式主要分为2种
*
* 1 透明式

  添加Component对象的操作定义在Component角色中，这样的话不仅Composite需要实现这些方法，Leaf也需要实现这些方法，
  而这些方法对于Leaf来说没有任何意义，不过将系统实现统一起来了，因此对用户来说透明（用户无需区分Composite还是Leaf）
  ，因为这些角色中都具备这些方法。
  
   2 安全式

  添加Component对象的操作定义在Composite角色中，这样的话Leaf就无需实现这些方法（因为Leaf本身根本不需要实现这些方法）
*
*/
public class Composite  implements Component{
  
  List<Component> list = new ArrayList<Component>();
  
  //添加
  public void addComponent(Component component){
    list.add(component);
  }
  //删除
  public void removeComponent(Component component){
    list.remove(component);
  }
  
  //get
  public List<Component> getAll(){
    return list;
  }
  
  public void run(){
    for(Component component : list){
      component.run();
    }
  }

}

package com.pattern.composite;  
  
public class Client {  
  
    public static void main(String[] args){  
        Leaf leaf1 = new Leaf();  
        Leaf leaf2 = new Leaf();  
        Leaf leaf3 = new Leaf();  
          
        Composite composite = new Composite();  
          
        composite.addComponent(leaf1);  
        composite.addComponent(leaf2);  
          
        Composite composite1 = new Composite();  
        composite1.addComponent(composite);  
        composite1.addComponent(leaf3);  
          
        composite1.run();  
          
    }  
}  

Tags - , , ]]> http://zhoujin.com/post/96/ <![CDATA[适配器(Adapter)模式(包装模式)]]> chirs <> Mon, 09 Jun 2008 07:42:57 +0000 http://zhoujin.com/post/96/ A:类适配器模式
B:对象适配器模式

都有三种角色
1:Target:供客户端调用
2:Adaptee:具体调用角色
3:Adapter:包装角色

A:类适配器模式

package com.pattern.adapter.classadapter;  
/**  
* 客户端要使用的目标类  
*  
*/  
public interface Target {  
      
    public void method1();  
  
}  

package com.pattern.adapter.classadapter;
/**
* 客户端要使用的目标类
*
*/
public interface Target {
  
  public void method1();

}

package com.pattern.adapter.classadapter;  
  
public class Adaptee {  
      
    public void method2(){  
        System.out.println("执行...");  
    }  
  
}  

package com.pattern.adapter.classadapter;
public class Adaptee {
  
  public void method2(){
    System.out.println("执行...");
  }

}

package com.pattern.adapter.classadapter;  
//继承Adaptee类  
public class Adapter extends Adaptee implements Target {  
  
    //包装类  
    public void method1() {  
        this.method2();  
    }  
  
}  

package com.pattern.adapter.classadapter;
//继承Adaptee类
public class Adapter extends Adaptee implements Target {

  //包装类
  public void method1() {
    this.method2();
  }

}
package com.pattern.adapter.classadapter;  
//适配器模式也叫包装模式  
public class Client {  
    //类适配器模式  
    public static void main(String[] args){  
        Target target = new Adapter();  
        target.method1();  
    }  
  
}  

package com.pattern.adapter.classadapter;
//适配器模式也叫包装模式
public class Client {
  //类适配器模式
  public static void main(String[] args){
    Target target = new Adapter();
    target.method1();
  }

}


B:对象适配器模式

package com.pattern.adapter.objectadapter;  
/**  
* 客户端要使用的目标类  
*  
*/  
public interface Target {  
    public void method1();  
}  

package com.pattern.adapter.objectadapter;
/**
* 客户端要使用的目标类
*
*/
public interface Target {
  public void method1();
}

package com.pattern.adapter.objectadapter;  
  
public class Adaptee {  
      
    public void method2(){  
        System.out.println("执行...");  
    }  
  
}  

package com.pattern.adapter.objectadapter;

public class Adaptee {
  
  public void method2(){
    System.out.println("执行...");
  }

}

package com.pattern.adapter.objectadapter;  
  
//不继承Adaptee类  
public class Adapter implements Target {  
  
    private Adaptee adaptee ;  
    public Adapter(Adaptee adaptee){  
        this.adaptee = adaptee;  
    }  
      
    public void method1() {  
        adaptee.method2();  
    }  
  
}  

package com.pattern.adapter.objectadapter;

//不继承Adaptee类
public class Adapter implements Target {

  private Adaptee adaptee ;
  public Adapter(Adaptee adaptee){
    this.adaptee = adaptee;
  }
  
  public void method1() {
    adaptee.method2();
  }

}
package com.pattern.adapter.objectadapter;  
//适配器模式也叫包装模式  
public class Client {  
    //对象适配器模式  
    public static void main(String[] args){  
        Target target = new Adapter(new Adaptee());  
        target.method1();  
    }  
  
}  

Tags - , , , ]]> http://zhoujin.com/post/91/ <![CDATA[CSS2.0的box模型]]> chirs <> Sat, 07 Jun 2008 16:38:31 +0000 http://zhoujin.com/post/91/

  • Content -实际显示文本或图片的区域，其宽度由css的width定义。
  • Padding -环绕Content的区域，通过padding-top, padding-right, padding-bottom, padding-left 和padding等属性来进行设定。
  • Border -环绕padding的区域，通过border-top, border-right, border-bottom, border-left 和border 等属性来进行设定。
  • Margin -环绕Border的区域，通过margin-top, margin-right, margin-bottom, margin-left 和margin 等属性来进行设定。

　　整个box的宽度= margin-left + border-left-width + padding-left + width + padding-right + border-right-width + margin-right

　　ms IE5误解了width的含义，结果把width定义成了content+border的宽度之和。下列两行的定义显示是相同：

  • CSS 2.0width: 100px; padding: 10px; border: 10px
  • IE 5width: 140px; padding: 10px; border: 10px
IE6虽然改正了这个错误，则需要通过正确的Doctype来指定浏览器的显示模式。

　　Eric Meyer在她的"CSS 2.0 Programer's Reference"一书中，更为详细地画出了box模型结构图。

参考文献：

  1. CSS Box Model
  2. Eric Meyer, CSS 2.0 Programer's Reference
  3. The Box Model Problem
  4. The Box Model Problem

Tags - , ]]> http://zhoujin.com/post/83/ <![CDATA[一段女生写的C语言代码]]> chirs <> Fri, 06 Jun 2008 02:32:00 +0000 http://zhoujin.com/post/83/
我是个孤独的幽灵，如此苍白和落寞。永远没有自己的生活方式，一只在空气中苦苦挣扎的鱼...
#include "stdio.h"
#include "stdlib.h"
result love(boy, girl) {
　　if ( boy.有房() and boy.有车()) {
　　　　boy.set(nothing);
　　　　return girl.嫁给(boy);
　　}
　　if ( girl.愿意等()) {
　　　while( ! (boy.赚钱 ＞ 100,000 and girl.感情> 8 ) ) {
　　　　for ( day=1; day ＜=365; day++) {
　　　　　if ( day == 情人节 )
　　　　　if ( boy.givegirl(玫瑰))
　　　　　　girl.感情++;
　　　　　　else
　　　　　　　girl.感情--;
　　　　　 if( day == girl.生日)
　　　　　    if ( boy.givegirl(玫瑰) )
　　　　　　　　girl.感情++;
　　　　　　　　else
　　　　　　　　girl.感情--;

　　　　　　boy.拼命赚钱();
　　　　　 }
　　　　 }
　　　　if ( boy.有房() and boy.有车() ) {
　　 boy.set(nothing);
　return girl.嫁给(boy);
　}
　　　年龄++;
　　　girl.感情--;
　　 }
　　return girl.goto( another_boy);
}
Tags - , , ]]> http://zhoujin.com/post/95/ <![CDATA[装饰(Decorator)模式]]> chirs <> Thu, 05 Jun 2008 07:37:30 +0000 http://zhoujin.com/post/95/ Decorator模式使原有功能增强，而且不是通过子类来实现功能增强的。

装饰模式主要特色：
1.用来扩展特定对象的功能，不是扩充某个类的功能。
2.不需要子类，防止由于子类而导致的复杂和混乱
3.对于一个给定的对象，同事可能有不同的装饰对象，客户端可以通过它的需要选择合适的装饰对象

java.io包下类大量使用到装饰模式。

装饰模式主要角色
1.抽象构件角色:给出一个抽象接口，以规范准备接受附加责任的对象
2.具体构件角色:定义一个将要接收附加责任的类
3.装饰角色：持有一个构件对象的实例，并定义一个与抽象构件接口一致的接口
4.具体装饰角色:负责给构件对象"贴上"附加的责任
Java代码
package com.pattern.decorator;  
/**  
* 抽象构件角色  
*/  
public interface Component {  
  
    public void doSomething();  
}  

package com.pattern.decorator;
/**
* 抽象构件角色
*/
public interface Component {

  public void doSomething();
}

package com.pattern.decorator;  
/**  
* 具体构件角色  
*/  
public class ConcreteComponent implements Component {  
  
    public void doSomething() {  
        System.out.println("功能A");  
    }  
}  

package com.pattern.decorator;
/**
* 具体构件角色
*/
public class ConcreteComponent implements Component {

  public void doSomething() {
    System.out.println("功能A");
  }

}

package com.pattern.decorator;  
/**  
* 装饰角色  
*/  
public class Decorator implements Component {  
    //拥有一个抽象构件对象  
    private Component component;  
    public Decorator(Component component){  
        this.component = component;  
    }  
    public void doSomething() {  
        component.doSomething();  
    }    
}  

package com.pattern.decorator;
/**
* 装饰角色
*/
public class Decorator implements Component {
    //拥有一个抽象构件对象
  private Component component;
  public Decorator(Component component){
    this.component = component;
  }
  public void doSomething() {
    component.doSomething();
  }

}


package com.pattern.decorator;  
/**  
* 具体装饰角色一  
*/  
public class ConcreteDecorator1 extends Decorator {  
  
    public ConcreteDecorator1(Component component){  
        super(component);  
    }  
      
    public void doSomething(){  
        super.doSomething();  
        this.doAnotherthing();  
          
    }  
    private void doAnotherthing(){  
        System.out.println("功能B");  
    }  
}  


package com.pattern.decorator;
/**
* 具体装饰角色一
*/
public class ConcreteDecorator1 extends Decorator {

  public ConcreteDecorator1(Component component){
    super(component);
  }
  
  public void doSomething(){
    super.doSomething();
    this.doAnotherthing();
    
  }
  private void doAnotherthing(){
    System.out.println("功能B");
  }
}

package com.pattern.decorator;  
/**  
* 具体装饰角色二  
*/  
public class ConcreteDecorator2 extends Decorator {  
  
    public ConcreteDecorator2(Component component){  
        super(component);  
    }  
      
    public void doSomething(){  
        super.doSomething();  
        this.doAnotherthing();  
          
    }  
    private void doAnotherthing(){  
        System.out.println("功能C");  
    }  
}  

package com.pattern.decorator;
/**
* 具体装饰角色二
*/
public class ConcreteDecorator2 extends Decorator {

  public ConcreteDecorator2(Component component){
    super(component);
  }
  
  public void doSomething(){
    super.doSomething();
    this.doAnotherthing();
    
  }
  private void doAnotherthing(){
    System.out.println("功能C");
  }
}

package com.pattern.decorator;  
/**  
* 客户端  
*/  
public class Client {  
      
    public static void main(String[] args){  
   //扩充了component 对象的功能。  
        Component component = new ConcreteDecorator2(new ConcreteDecorator1(new ConcreteComponent()));  
        component.doSomething();  
    }  
}

Tags - , , ]]> http://zhoujin.com/post/82/ <![CDATA[buffalo使用问题集锦]]> chirs <> Tue, 03 Jun 2008 08:27:50 +0000 http://zhoujin.com/post/82/
var int1=document.getElementsByName("a");

页面用js封装成array,后台用String[]接收.
2.解决传递web页面多个表单
当增加一条数据时。获取前台页面表单值。如果有很N个。。

<form id="addForm" >
<input id="add.name" >
<input id="add.address">
<input id="add.tel">。。。。。。N个。
</form>

做法。

var addObj = {};
addObj[Buffalo.BOCLASS]="com.ptn.opera.domain.user.User";


接下来对以对传递对象的方式处理页面上的所有表单的参数

FormUtil.formToObject("addForm",addObj,"add");

之后利于

buffalo.remoteCall("userService.addUsers", [addObj], function(reply){
if (reply.isFault()) {
alert(reply.getResult());
} else {
alert(reply.getResult());
}
});



对方法 FormUtil。formToObject代码 如下。

对于其中的("jType")实际出现在
<input id="add.id" jtpye="int" >
对表单值类型转换


FormUtil.formToObject = function(formId, obj, objName) {
var formObj = document.getElementById(formId);
var elements = formObj.elements;
for (var i=0; i<elements.length; i++) {
var elemName = elements[i].name;
if (elemName.indexOf(objName) != 0) {
continue;
}
elemName = elemName.substring(objName.length + 1);
var jType = elements[i].getAttribute("jType");
if (jType != null) {
if (jType == "int") {
obj[elemName] = parseInt(elements[i].value);
} else if (jType == "Date" && elements[i].value != "") {
var d = {};
d[Buffalo.BOCLASS] = "java.sql.Timestamp";
var dateValue = elements[i].value;
var year = dateValue.substring(0,4);
var monthDay = dateValue.substring(5, 10);
var hhmmss = dateValue.substring(10);
dateValue = monthDay + "-" + year + hhmmss;
alert(dateValue);
var dateTime = new Date(dateValue);
//var dateTime = new Date("01-26-2007 23:21:20");
dateTime.setHours(dateTime.getHours() - 8);
d["value"] = dateTime;
obj[elemName] = d;
}
} else {
obj[elemName] = elements[i].value;
}
}
}

Tags - , , ]]> http://zhoujin.com/post/81/ <![CDATA[buffalo与spring集成]]> chirs <> Tue, 03 Jun 2008 08:07:01 +0000 http://zhoujin.com/post/81/
<bean name="simpleService" class="net.buffalo.demo.simple.SimpleService"></bean>

然后再在spring相关配置文件中加入如下配置：

<bean name="buffaloConfigBean" class="net.buffalo.service.BuffaloServiceConfigurer">
　　<property name="services">
            <map>
                <entry key="springSimpleService">
                    <ref bean="simpleService"/>
                </entry>

            </map>
        </property>
</bean>

另外，官方版本只支持spring启动方式为：
org.springframework.web.context.ContextLoaderServlet
]]> http://zhoujin.com/post/77/ <![CDATA[智慧与人品 — 周国平]]> chirs <> Sat, 31 May 2008 04:33:00 +0000 http://zhoujin.com/post/77/
　　文明之对于不同的人，往往进入其不同的心理层次。进入意识层次，只是学问；进入无意识层次，才是教养。

　　有两种人最不会陷入琐屑的烦恼,最能够看轻外在的得失.他们似是两个极端：自信者和厌世者。前者知道自己的价值，后者知道世界的无价值。

　　狂妄者往往有点才气，但无知，因无知而不能正确估量自己这一点才气。这是少年人易犯的毛病，阅历常能把它治愈。

　　傲慢者却多半是些毫无才气的家伙，不但无知，而且无礼，没有教养。这差不多是一种人格上的缺陷，极难纠正。

　　真正相信自己的人是很少的，有些人的自信不过是一种“有益的盲目”，似乎下意识地知道自己内心的空虚，避免去看透自己，以维持虚假的充实。真正的自信者必是有勇气正视自己的人，而这样的自信也必定和对

　　自己的怀疑及不满有着内在的联系。这种人的自信必须靠自己去争得。事实上，几乎所有伟大的天才都并非天性自信的人，相反倒有几分自卑，他们知道自己的弱点，为这弱点而苦恼，不肯毁于这弱点，于是奋起自强，反而有了令一般人吃惊的业绩。

　　我相信，天才骨子里都有一点自卑，成功的强者内心深处往往埋着一段屈辱的经历。
Tags - , , , , , ]]> http://zhoujin.com/post/90/ <![CDATA[[转]马云经典语录！]]> chirs <> Wed, 28 May 2008 02:44:25 +0000 http://zhoujin.com/post/90/
1 ：这世界上没有优秀的理念，只有脚踏实地的结果。
2 ：有时候死扛下去总是会有机会的。
3 ：建立自我、追求忘我。
4 ：天不怕，地不怕，就怕CFO当CEO。
5 ：永远要相信边上的人比你聪明。
6 ：五年以后还想创业，你再创业。
7 ：上当不是别人太狡猾，而是自己太贪，是因为自己才会上当。
8 ：其实很多人的问题是因为他们回答的全是对的。
9 ：一个一流的创意，三流的执行，我宁可喜欢一个一流的执行，三流的创意。
10：蒙牛不是策划出来的，而是踏踏实实的产品、服务和体系做出来的。
11：最优秀的模式往往是最简单的东西。
12：要少开店、开好店，店不在于多，而在于精。
13：创业者书读得不多没关系，就怕不在社会上读书。
14：在今天的商场上已经没有秘密了，秘密不是你的核心竞争力。
15：很多人失败的原因不是钱太少，而是钱太多。
16：概念到今天这个时代已经不能卖钱了。
17：创业者光有激情和创新是不够的，它需要很好的体系、制度、团队以及良好的盈利模式。
18：这个世界不是因为你能做什么，而是你该做什么。
19：你的项目感觉是一个生意，不是一个独特的企业。
20：建一个公司的时候要考虑有好的价值才卖。如果一开始想到卖，你的路可能就走偏掉。
21：人要有专注的东西，人一辈子走下去挑战会更多，你天天换，我就怕了你。
22：要找风险投资的时候，必须跟风险投资共担风险，你拿到的可能性会更大。
23：记住，关系特别不可靠，做生意不能凭关系，做生意也不能凭小聪明。
24：不要贪多，做精做透很重要，碰到一个强大的对手或者榜样的时候，你应该做的不是去挑战它，而是去弥补它。
25：赚钱模式越多越说明你没有模式。
26：一个好的东西往往是说不清楚的，说得清楚的往往不是好东西。
27：如果你看了很多书，千万别告诉别人，告诉别人别人就会不断考你。
28：做战略最忌讳的是面面俱到，一定要记住重点突破，所有的资源在一点突破，才有可能赢。
29：小企业有大的胸怀，大企业要讲细节的东西。
30：做企业不是做侠客。
31：所有的创业者应该多花点时间，去学习别人是怎么失败的。
32：关注对手是战略中很重要的一部分，但这并不意味着你会赢。
33：战略不能落实到结果和目标上面，都是空话。
34：绝大部分创业者从微观推向宏观，通过发现一部分人的需求，然后向一群人推起来。
35：不管你拥有多少资源，永远把对手想得强大一点。
36：80年代的人不要跟70年代，跟60年代的人竞争，而是要跟未来，跟90年代的人竞争，这样你才有赢的可能性。
37：商业计划绝对不是一个销售计划，里面有无数细节，无数人才的运营。
38：战略有很多意义，小公司的战略简单一点，就是活着，活着最重要。
39：必须先去了解市场和客户的需求，然后再去找相关的技术解决方案，这样成功的可能性才会更大。
40：最核心的问题是根据市场去制定你的产品，关键是要倾听客户的声音。
41：免费是世界上最昂贵的东西。所以尽量不要免费。等你有了钱以后再考虑免费。
42：“营销”这两个字强调既要追求结果，也要注重过程，既要“销”，更要“营”。
43：诚信绝对不是一种销售，更不是一种高深空洞的理念，它是实实在在的言出必行、点点滴滴的细节。
44：公关是个副产品，由于你解决了以后会逐渐传出去，这才是最好的公关。
45：短暂的激情是不值钱的，只有持久的激情才是赚钱的。
46：聪明是智慧者的天敌，傻瓜用嘴讲话，聪明的人用脑袋讲话，智慧的人用心讲话。
47：永远要把对手想得非常强大，哪怕非常弱小，你也要把他想得非常强大。
48：我自己不愿意聘用一个经常在竞争者之间跳跃的人。
49：多花点时间在你的其他员工身上。
50：什么是团队呢?团队就是不要让另外一个人失败，不要让团队任何一个人失败。
51：把你太太当合作伙伴，不要把她当太太看。
52：有时候学历很高不一定把自己沉得下来做事情。
53：创业时期千万不要找明星团队，千万不要找已经成功过的人。创业要找最适合的人，不要找最好的人。
54：最大的挑战和突破在于用人，而用人最大的突破在于信任人。
55：什么都想自己干，这个世界上你干不完。
56：每一笔生意必须挣钱，免费不是一个好策略，它付出的代价会非常大。
57：领导力在顺境的时候，每个人都能出来，只有在逆境的时候才是真正的领导力。
58：碰到灾难第一个想到的是你的客户，第二想到你的员工，其他才是想对手。
59：永远记住每次成功都可能导致你的失败，每次失败好好接受教训，也许就会走向成功。
60：暴躁在某种程度上讲是因为有不安全感，或者是自己没有开放的心态。
61：可能一个人说你不服气，两个人说你不服气，很多人在说的时候，你要反省，一定是自己出了一些问题。
62：一个成功的创业者，三个因素，眼光、胸怀和实力。
63：别人可以拷贝我的模式，不能拷贝我的苦难，不能拷贝我不断往前的激情。
64：80年代的人还需要摔打，不管做任何事，要检查主观原因。
65：做小了，一定要做到独特。
66：人永远不要忘记自己第一天的梦想，你的梦想是世界上最伟大的事情，就是帮助别人成功。
67：不想当将军的士兵不是好士兵，但是一个当不好士兵的将军一定不是好将。
68：小公司的战略就是两个词：活下来，挣钱。
69：生存下来的第一个想法是做好，而不是做大。
70：《赢在中国》没有失败者，只有幸运者。
71：有结果未必是成功，但是没有结果一定是失败。
72：永远把别人对你的批评记在心里，别人的表扬，就把它忘了。
73：权威是你把权给别人的时候，你才能有真正的权利，你懂得倾听、懂得尊重，承担责任的时候，别人一定会听你，你才会有权威。
Tags - , ]]> http://zhoujin.com/post/73/ <![CDATA[闲人]]> chirs <> Sun, 25 May 2008 10:44:55 +0000 http://zhoujin.com/post/73/ 不小心就沉迷于泡泡的美丽景致当中，
喜欢穿梭于网络的感觉，是得是失已经不是三言两语就说得清楚的，
只是，从不想否认在网络中的快乐还是多过苦恼，
更不想否认其实充实的感觉还是多过空虚……
生活中无奈已有太多，就把论坛当作是自己的家，
开心也好，烦恼也好，
这份来之不易的缘更要好好珍惜！！
Tags - ]]> http://zhoujin.com/post/103/ <![CDATA[javascript---类的继承]]> chirs <> Fri, 16 May 2008 08:07:46 +0000 http://zhoujin.com/post/103/ 第一种方式,冒充对象的方式.(利用js里的每一个方法名都是一个Function对象)
//第一种方式,冒充对象的方式.(利用js里的每一个方法名都是一个Function对象)  
function Parent(username){  
    this.username = username;  
    this.say = function(){  
        alert(this.username);  
    }  
}    
function Child(username,password){      
    this.temp = Parent;//temp指向Parent所指向的地方 。 利用js里的每一个方法名都是一个Function对象,指向一个方法。  
    this.temp(username);//初始化方法里的内容  
    delete this.temp;//temp没有用了。可以直接删除掉.this不可以丢了      
    //Parent(username);//这样写表面看起来是正确的，其实是错误的。因为只有new出来的对象才有this,所以调用Parent里的this就没有值了      
    this.password = password;  
    this.hello = function(){  
        alert(this.password);  
    }  
}  
var parent = new Parent("zhangsan");  
parent.say();//zhangsan
  
var child = new Child("lisi","123456");  
child.say();//lisi  
child.hello();//123456

2.第二种方式：call()函数方式 //call()函数是Function对象的一个函数  
//具体用法如  
function test(str){  
    alert(this.username + ","  + str);  
}  
  
var o = new Object();  
o.username = "zhangsan";  
test.call(o,"123456");//zhangsan,123456 .因为每个Function 对象都有一个call()方法，而函数名就是一个Function对象.call()函数的第一个参数是test函数里的this.  

//call()函数是Function对象的一个函数
//具体用法如
function test(str){
  alert(this.username + ","  + str);
}

var o = new Object();
o.username = "zhangsan";
test.call(o,"123456");//zhangsan,123456 .因为每个Function 对象都有一个call()方法，而函数名就是一个Function对象.call()函数的第一个参数是test函数里的this.

所以继承可以这样实现：
function Parent(username){  
    this.username = username;  
    this.say = function(){  
        alert(this.username);  
    }  
}  
function Child(username,password){  
    Parent.call(this,username);  
    this.password = password;  
    this.hello = function(){  
        alert(this.password);  
    }  
}  
var parent = new Parent("zhangsan");  
parent.say();//zhangsan  
  
var child = new Child("lisi","123456");  
child.say();//lisi  
child.hello();//123456


3.第三种实现方式:apply()函数方式，apply()和call()是一样的，只不过参数传递不同而已,apply的参数为数组
//第三种实现方式:apply()函数方式，apply()和call()是一样的，只不过参数传递不同而已,apply的参数为数组  
//所以继承可以这样实现  
  
function Parent(username){  
    this.username = username;  
    this.say = function(){  
        alert(this.username);  
    }  
}  
function Child(username,password){  
    Parent.apply(this,new Array(username));  
    this.password = password;  
    this.hello = function(){  
        alert(this.password);  
    }  
}  
var parent = new Parent("zhangsan");  
parent.say();//zhangsan  
  
var child = new Child("lisi","123456");  
child.say();//lisi  
child.hello();//123456  

4. 第4种方式:原型链实现继承
//原型链实现继承  
function Parent(){  
}  
Parent.prototype.hello = "hello";  
Parent.prototype.sayHello = function(){  
    alert(this.hello);  
}  
  
function Child (){  
}  
Child.prototype = new Parent();//关键  
  
Child.prototype.world = "world";  
Child.prototype.sayWorld = function(){  
    alert(this.world);  
}  
  
var child = new Child();  
child.sayHello();  
child.sayWorld();


5.第五种方式:混合模式实现继承
//混合模式实现继承  
function Parent(hello){  
    this.hello = hello;  
}  
Parent.prototype.sayHello = function(){  
    alert(this.hello);  
}  
  
function Child(hello,world){  
    this.world = world;  
    Parent.call(this,hello);//关键  
  
}  
Child.prototype = new Parent(); //关键  
Child.prototype.sayWorld = function(){  
    alert(this.world);  
}  
  
var child = new Child("hello","world");  
child.sayHello();  
child.sayWorld();  

Tags - , , ]]> http://zhoujin.com/post/102/ <![CDATA[javascript---类的构建]]> chirs <> Thu, 15 May 2008 07:57:10 +0000 http://zhoujin.com/post/102/ 1.构造方式定义类
2.原型方式定义类
3.构造和原型结合方式创建类
4.动态的原型方式

各有优缺点,具体如下
1.构造方式定义类，优点:多个实例对象不共享类的属性值，缺点:每个实例对象都会产生出一个函数say

//构造方式定义类，优点:多个实例对象不共享类的属性值，缺点:每个实例对象都会产生出一个函数say  
function User(){  
    this.username = "zhangsan";//this.不能丢  
      
    this.say = function(){//this.不能丢  
        alert("username:" + this.username );//this.不能丢  
    }  
    //下面注释的这种写法不对  
//  function say(){  
//      alert("username:" + this.username );  
//  }  
}  
  
var user = new User();  
user.username = "lisi";  
user.say();//username:lisi  
  
var user1 = new User();  
user1.say();//username:zhangsan,不受user对象的影响  

//构造方式定义类，优点:多个实例对象不共享类的属性值，缺点:每个实例对象都会产生出一个函数say
function User(){
  this.username = "zhangsan";//this.不能丢
  
  this.say = function(){//this.不能丢
    alert("username:" + this.username );//this.不能丢
  }
  //下面注释的这种写法不对
//  function say(){
//    alert("username:" + this.username );
//  }
}

var user = new User();
user.username = "lisi";
user.say();//username:lisi

var user1 = new User();
user1.say();//username:zhangsan,不受user对象的影响



//多个实例对象不共享类的属性值:
//多个实例对象不共享类的属性值，如下:  
function User(){  
    this.username = new Array();//this.不能丢  
      
    this.say = function(){//this.不能丢  
        alert("username:" + this.username );//this.不能丢  
    }  
}  
  
var user = new User();  
user.username.push("zhangsan");  
user.say();//username:zhangsan  
  
var user1 = new User();  
user1.say();//user1的username为空，不为zhangsan,因为user1的属性值不受user影响


2.原型方式定义类,缺点:类的属性值如果是引用类型的(非Number和String类型)，则多个实例对象共享
//原型方式定义类,缺点:类的属性值如果是引用类型的(非Number和String类型)，则多个实例对象共享  
function User(){  
}  
User.prototype.username = "zhangsan";  
User.prototype.say = function(){  
    alert("username: " + this.username );  
}  
  
var user = new User();  
user.username = "lisi";  
user.say();//username:lisi  
  
var user1 = new User();  
user1.say();//username:zhangsan  

//原型方式定义类,缺点:类的属性值如果是引用类型的(非Number和String类型)，则多个实例对象共享
function User(){
}
User.prototype.username = "zhangsan";
User.prototype.say = function(){
  alert("username: " + this.username );
}

var user = new User();
user.username = "lisi";
user.say();//username:lisi

var user1 = new User();
user1.say();//username:zhangsan



类的属性值如果是引用类型的(非Number和String类型)，则多个实例对象共享：
//类的属性值如果是引用类型的(非Number和String类型)，则多个实例对象共享,如下  
function User(){  
}  
User.prototype.username = new Array();  
User.prototype.say = function(){  
    alert("username: " + this.username );  
}  
  
var user = new User();  
user.username.push("zhangsan") ;  
user.say();//username:zhangsan  
  
var user1 = new User();  
user1.say();//username:zhangsan,因为user1属性也会受到user的影响，user1和user指向同一引用，即共享同一属性
3.构造和原型结合方式创建类:优点:类的方法只会产生一个，不会产生大量方法,同时属性还不共享;缺点:属性和方法分开定义不是太好。
//构造和原型结合方式创建类:优点:类的方法只会产生一个，不会产生大量方法,同时属性还不共享;缺点:属性和方法分开定义不是太好。  
function User(){  
    this.username = "zhangsan";  
}  
User.prototype.say = function(){  
    alert("username: " + this.username );  
}  
var user = new User();  
alert(user.username);  


4.动态的原型方式:优点:类的方法只会产生一个，不会产生大量方法,同时属性还不共享,同时属性和方法不是分开定义的

////动态的原型方式:优点:类的方法只会产生一个，不会产生大量方法,同时属性还不共享,同时属性和方法不是分开定义的
function User(){
  this.username = "zhangsan";
  
  if(typeof User.flag == "undefined"){
    alert("execute...");
    User.prototype.say = function(){
      alert("username: " + this.username );
    }
    
    User.flag = true;
  }
}

var user1 = new User();//execute...
var user2 = new User();//不会打印出execute...，则说明方法只创建了一次，即方法只会产生一个
user1.say();//username


总结:
构造方式定义类:缺点:类里的方法，每个实例对象都会产生一个，导致产生大量方法;优点:所有实例对象都单独拥有一份类里的属性，即属性不共享
原型方法定义类:缺点:所有实例对象都共同拥有一份类里的属性，即属性共享。优点:类的方法只会产生一个，不会产生大量方法
构造和原型结合方式创建类:优点:类的方法只会产生一个，不会产生大量方法,同时属性还不共享;缺点:属性和方法分开定义不是太好。
动态的原型方式:优点:类的方法只会产生一个，不会产生大量方法,同时属性还不共享,同时属性和方法不是分开定义的
Tags - , , ]]> http://zhoujin.com/post/89/ <![CDATA[CSS中Float概念相关文章采撷]]> chirs <> Wed, 14 May 2008 13:43:41 +0000 http://zhoujin.com/post/89/ 原始出处

Float（浮动）概念也许是CSS中最让人迷惑的一个概念吧。Float经常被错误理解，而且因为将上下文元素全部浮动导致的可读性、可用性问题备受责难。然而，这些问题的根源并不在于理论本身，而是开发人员以及浏览器对理论的解读造成的。

如果你认真的去读一下浮动概念，你会发现并不像所见的那样复杂。大多数问题都是由于老版本的IE带来的（我只是猜想）。如果你知道这些bug，你就能避免这些问题。

让我们尝试去解决这些问题并澄清一些以前使用浮动的误解。我们参考了成打的相关文章，并选取了最为重要的一些你必须了解的问题。
What You Should Know About Floats

“关于图文围绕的实践可以追溯到很久很久以前。这也就是为什么从Netscape1.1开始这个功能被引入浏览器，以及为什么CSS使用浮动属性来实现它。‘Float(浮动)’这个术语引用自伴随Netscape1.1一同发布的‘Additions to HTML 2.0’文档，描述一个元素浮动至某一侧并停下的表现方式。”[Containing Floats]

“浮动元素的定位还是基于正常的文档流，然后从文档流中抽出并尽可能远的移动至左侧或者右侧。文字内容会围绕在浮动元素周围。当一个元素从正常文档流中抽出后，仍然在文档流中的其他元素将忽略该元素并填补他原先的空间。” [Float Positioning]

“元素浮动后将自动转为块级元素。该元素可以被移动至当前行的左侧或右侧。属性如下：float: left, float: right or float: none”[Floatutorial: Float Basics]

“你应该为所有的浮动元素设定宽度属性（除非是＜img＞元素，因其具有隐含的宽度）。如果不设定宽度，结果将是不可预知的。”[Floatutorial: Float Basics]

“举例来说，浮动元素应该定义宽度属性，不论是显式指定的还是隐含的。另外，它会尽可能的水平的填充容器元素，就像非浮动内容那样，不给其他内容空间以围绕它们。其次，和正常文档流中的元素不同，浮动元素的垂直边距(margin)不会叠加。最后，浮动元素可以和临近在正常文档流中块级元素重叠（译注：浮动元素不占任何正常文档流空间，所以建议不要理解成重叠，而是腾空浮动的概念。）。”[CSS Positioning: Floats]

“首先我们要牢记的一件事情是，浮动元素只能浮动至左侧或者右侧，没有浮动至中间一说，这是很多新手容易范的错误。记住，最基本的规则，浮动元素只能浮动至两侧。” [Float Layouts]

“当我们让一个元素浮动，它会往右或者往左浮动直至遇到容器的边缘。如果我们向同一方向再浮动一个元素，它会浮动直至碰到前一个浮动元素的边缘。如果我们浮动更多的元素，他们将一个挨一个排列，但不久就会空间不足，当该行已经无法容纳更多的浮动元素，则下一个浮动元素会换行继续排列。” [Float Layouts]

Containing blocks or containing boxes：“容器元素是指包含其他子元素的行级或块级元素。。。。” [Floatutorial]

“当明确指定时，浮动元素垂直位置由它原先在文档流中的位置决定，顶端与当前行顶端对其。但是水平方向上，它尽可能远的向容器元素边缘移动，但是仍遵循容器元素的填充距离(padding)。同行的行内元素则围绕浮动元素排列。” [CSS Positioning: Floats]

“由于浮动元素不占据正常文档流空间，所以浮动元素前后那些未明确指定位置的块级元素会占据浮动元素本来应该处在的位置，就好像它从来不曾存在过。而浮动元素之后的那行会根据浮动元素缩小宽度。浮动元素之前的元素则会重新被排列，占据独立的一行。（译注：ie 和 ff 在这种情况下的表现不尽相同）” [W3C Visual Formatting Model]

“如果当前行的水平方向上没有足够的空间容纳浮动元素，则向下一行，直至有能容纳该元素的行。” [Floatutorial: Float Basics]

“任何浮动元素都不可能超过原来所处文档留位置的上边界。浮动元素的顶端必定和当前行顶端对齐（或者在没有当前行元素时和前一个块级元素底部边缘对齐）。”[Float Layouts]

“想要真正理解浮动理论，你必须明白在CSS中什么是行 (line box)。不幸的是，为了解释什么是行，你必须先明白什么是行级元素。行级元素指的是那些非块级元素，例如＜em＞而行是一个逻辑上的概念，是一个虚拟的矩形，包含了组成该行的所有行级元素，其高度至少等于这些行级元素中最高的那个。” [Float Layouts]

“如果我们将Div中所有的列都加上 float: left 它们会挨个向左排列，如果我们希望在页面底部有一个页脚，并不需要一个最长的列，只要加上 clear: both 就可以了”[Float Layouts]

“使用浮动元素包含浮动元素这样的布局方式有一个潜在的缺点，即你的页面是否能够一直保持一致的展现效果将取决于浏览器的实现是否保持一致。特别是当浮动元素是一个更为复杂的布局中的一部分的话，将变得更加不堪一击。”[Containing Floats]

Clearing the floats


“浮动元素之后的元素会自动围绕该浮动元素。如果你不希望这样，你可以为这些元素应用‘clear’属性。该属性有4种设值：clear: left, clear: right, clear: both or clear: none”[Floats and “clear”]

有很多技巧可以做到清理浮动元素，但不引入额外的无语义标签。下面3种是比较常见的做法： a) 将容器元素一起浮动 b) 在容器元素上使用 overflow: hidden c) 使用:after这样的css伪类。 [How to clear CSS floats without extra markup]

“插入一个清理元素是使容器正确包裹所有浮动元素的标准做法，这样做具有将容器底部边缘‘拖拉’以包裹所含元素的效果。” [How To Clear Floats Without Structural Markup]

“对于基于浮动设计的布局来说，一个常见的问题就是浮动元素的容器不会自动伸展来包含浮动元素。如果你希望在所有的浮动元素的外面加上边框（例如，在容器元素上加上边框），这样你必须显示的命令浏览器来伸展容器。你可以是用overflow method方法。”

使用:after 想像一下我们使用:after来插入一个点号，并且设置它的属性{clear: both;}。这就是所有你需要做的事情，但是没有人会接受容器底部有那么一丝空隙，所以我们还要设置{height: 0;} 和 {visibility: hidden;} 来保证严丝合缝。 [How To Clear Floats Without Structural Markup]


Tags - , , , ]]> http://zhoujin.com/post/101/ <![CDATA[javascript特性二]]> chirs <> Tue, 13 May 2008 07:55:21 +0000 http://zhoujin.com/post/101/ User = function (){  
}  
User.prototype.name = "zhangsan";  
//User.name = "zhangsan";//错误定义  
          
var u = new User();  
u.password = "123456";  
//u.prototype.password = "987654";//错误定义  
alert(u.name);  
alert(u.password);  
2. js里的数组
//数组定义，第一种定义方式  
var arr = new Array();  
//数组赋值  
arr.push(1);  
arr.push(2);  
arr[2] = 3;  
alert(arr.length);//3  
  
//第二种定义方式  
var arr1 = [];  
arr1.push(1);  
arr1.push(2);  
arr1[2] = 3;  
alert(arr1.length);//3  
  
//第三种定义方式  
var arr2 = [1,2,3,4,5];  
arr2[5] = 6;  
alert(arr2.length);//6  
  
  
//数组排序sort()方法  
var arr3 = [1,4,2];  
arr3.sort();  
alert(arr3);//1,2,4  
  
//  
var arr3 = [1,4,23];  
arr3.sort();  
alert(arr3);//1,23,4  顺序不对的原因是因为js里排序会先转换为字符串，再根据ascii码进行排序。所以23排在了4的前面  
  
//    
function compare(num1,num2)  
{  
    //因为排序前都转化成了字符串，所以要给parse成int,可以用函数parseInt()函数  
     var temp1 = parseInt(num1);  
     var temp2 = parseInt(num2);  
     if(temp1 < temp2)  
     {  
        return -1;  
     }else if(temp1 == temp2){  
        return 0;  
     }else{  
        return 1;  
     }  
}  
  
var arr4 = [1,4,23];  
arr4.sort(compare);//1,4,23 因为通过自定义函数compare进行了转换  
alert(arr4);  

//数组定义，第一种定义方式
var arr = new Array();
//数组赋值
arr.push(1);
arr.push(2);
arr[2] = 3;
alert(arr.length);//3

//第二种定义方式
var arr1 = [];
arr1.push(1);
arr1.push(2);
arr1[2] = 3;
alert(arr1.length);//3

//第三种定义方式
var arr2 = [1,2,3,4,5];
arr2[5] = 6;
alert(arr2.length);//6


//数组排序sort()方法
var arr3 = [1,4,2];
arr3.sort();
alert(arr3);//1,2,4

//
var arr3 = [1,4,23];
arr3.sort();
alert(arr3);//1,23,4  顺序不对的原因是因为js里排序会先转换为字符串，再根据ascii码进行排序。所以23排在了4的前面

//
function compare(num1,num2)
{
  //因为排序前都转化成了字符串，所以要给parse成int,可以用函数parseInt()函数
     var temp1 = parseInt(num1);
     var temp2 = parseInt(num2);
     if(temp1 < temp2)
     {
       return -1;
     }else if(temp1 == temp2){
       return 0;
     }else{
       return 1;
     }
}

var arr4 = [1,4,23];
arr4.sort(compare);//1,4,23 因为通过自定义函数compare进行了转换
alert(arr4);
]]> http://zhoujin.com/post/100/ <![CDATA[javascript特性一]]> chirs <> Mon, 12 May 2008 07:51:52 +0000 http://zhoujin.com/post/100/
function add(number)  
{  
   alert("hello");  
}  

function add(number)
{
   alert("hello");
}

等价于
var add = new Function("number","alert('hello');");  

var add = new Function("number","alert('hello');");


由于js里每一个函数里都隐含一个对象叫arguments,该arguments是一个数组，通过arguments可以获得到实际传递参数的个数(arguments.length)及实际传递参数的值(arguments[0],arguments[1]...)
所以可以通过arguments对象来模拟重载，如下：
function add()  
{  
    if(arguments.length == 1)  
    {  
          alert(arguments[0] + 10);  
    }  
    if(arguments.length == 2)  
    {  
               alert(arguments[0] + arguments[1] + 10);  
    }  
              
    }  
}  
add(5);  
add(5,1);  

function add()
{
  if(arguments.length == 1)
  {
        alert(arguments[0] + 10);
  }
  if(arguments.length == 2)
  {
               alert(arguments[0] + arguments[1] + 10);
  }
      
  }
}
add(5);
add(5,1);



2.每个函数的名字都有一个属性叫length,“属性名.length ”获得该函数能接受参数的个数。
如：
function a1()  
{  
}  
function a2(number)  
{  
}  
          
alert(a1.length);//0  
alert(a2.length);//1  

function a1()
{
}
function a2(number)
{
}
    
alert(a1.length);//0
alert(a2.length);//1



3.JavaScript中有五种原始基本数据类型：Undefined,Null,Boolean,Number,String

Undefined数据类型的值只有一个：undefined

Null数据类型的值只有一个：null

Boolean数据类型的值只有两个：true，false

Number数据类型的值有很多：数字即可

String a = "hello";和String a = new String("hello");是不一样的。有点类似java里的对象。String a = "hello"只是在栈内存里生成，String a = new String("hello");则堆内存里生成"hello"值，栈内容里变量a指向堆内存。

4.typeof一元操作符，它的返回值有五个：undefined,boolean,number,string,object

5.alert(函数名) 是把该函数的函数名及函数体都给打印出来。方便调试 javascript.

如：
function test()  
{  
    var a = "aa";  
}  
alert(test());//undefined  
alert(test);//function test(){ var a = "aa";}  
<SPAN style="COLOR: red">对于函数来说，如果其不返回值，那么其返回值就为undefined</SPAN>  

function test()
{
    var a = "aa";
}
alert(test());//undefined
alert(test);//function test(){ var a = "aa";}
对于函数来说，如果其不返回值，那么其返回值就为undefined

6.
var s ;//变量s1未定义  
alert(typeof s);//undefined  
alert(typeof s1);//undefined  
alert(s);//undefined  
alert(s1);//报错  

var s ;//变量s1未定义
alert(typeof s);//undefined
alert(typeof s1);//undefined
alert(s);//undefined
alert(s1);//报错


7.null与undefined的关系：undefined实际上从null派生而来
alert(undefined == null);//true  

alert(undefined == null);//true


8.对于函数定义中的变量来说，加var表示局部变量，不加var表示全局变量

9.javascript里 ，Object类是所有类的父类，类的强制转换有三种：Boolean(value),Number(value),String(value)

Object 对象有个方法叫：propertyIsEnumerable("属性名")
所以所有子类都有该方法，如果 "对象.propertyIsEnumerable("属性名")"为true，则表示该属性可以通过for(var temp in 对象的实例名)来进行遍历出来。
如：
var o = new Object();  
alert(o.propertyIsEnumerable("prototype"));//false,说明prototype是不可以通过for(var temp in )进行遍历出来的  

var o = new Object();
alert(o.propertyIsEnumerable("prototype"));//false,说明prototype是不可以通过for(var temp in )进行遍历出来的


Object对象里的所有属性propertyIsEnumerable都为 false
var o = new Object();  
for(var temp  in  o)  
{  
    alert(temp);    //一个都不会打印出来    
}  

var o = new Object();
for(var temp  in  o)
{
  alert(temp);  //一个都不会打印出来  
}


可以把o改为内置window对象，就可以打印出来很多了。

10.定义对象后增加属性或删除属性
var o = new Object();  
o.name="test";  
alert(o.name);//test  
delete o.name;  
alert(o.name);//undefined

Tags - , ]]> http://zhoujin.com/post/88/ <![CDATA[Javascript与CSS在IE和Firefox中的误区及区别]]> chirs <> Fri, 09 May 2008 09:36:41 +0000 http://zhoujin.com/post/88/ 现有代码中许多集合类对象取用时使用 ()，IE 能接受，Firefox 不能。
解决方法：改用 [] 作为下标运算。如：document.forms("formName") 改为
document.forms["formName"];  
//又如：  
document.getElementsByName("inputName")(1);  
//改为  
document.getElementsByName("inputName")[1];  

2. DIV对象
在 IE 中，DIV对象可以使用ID作为对象变量名直接使用。在 Firefox 中不能。
DivId.style.display = "none";
解决方法：document.getElementById("DivId").style.display = "none";
ps:得对象的方法不管是不是DIV对象，都应该使用getElementById方法。

3. 关于frame
现有问题：在 IE中 可以用window.testFrame取得该frame，mf中不行
解决方法：在frame的使用方面Firefox和IE的最主要的区别是：
如果在frame标签中书写了以下属性：
那么IE可以通过id或者name访问这个frame对应的window对象
而mf只可以通过name来访问这个frame对应的window对象
例如如果上述frame标签写在最上层的window里面的htm里面，那么可以这样访问
IE： window.top.frameId或者window.top.frameName来访问这个window对象
Firefox：只能这样window.top.frameName来访问这个window对象
另外，在mf和ie中都可以使用window.top.document.getElementById("frameId")来访问frame标签
并且可以通过window.top.document.getElementById("testFrame").src = 'xx.htm'来切换frame的内容
也都可以通过window.top.frameName.location = 'xx.htm'来切换frame的内容

4. 窗口
现有问题：IE中可以通过showModalDialog和showModelessDialog打开模态和非模态窗口，但是Firefox不支持。
解决办法：直接使用window.open(pageURL,name,parameters)方式打开新窗口。
如果需要传递参数，可以使用frame或者iframe。

5. 在JS中定义各种对象变量名时，尽量使用id，避免使用name.
在 IE 中，HTML 对象的 ID 可以作为 document 的下属对象变量名直接使用。在 Firefox 中不能，所以在平常使用时请尽量使用id，避免只使用name，而不使用id。

6. document.all
Firefox可以兼容document.all， 但会生成一条警告。可以用getElementById("*") 或者 getElementByTagName("*)来代替
不过对于document.all.length等属性，则完全不兼容。大家尽量不要使用document.all属性.

7. parentElement
IE中支持使用parentElement和parentNode获取父节点.
而Firefox只可以使用parentNode.

8. event
W3C不支持windows.event
比方说,在IE里面:
function onMenuClick(){  
    collapseMenu(event.srcElement);  
}

工作正常。不过在Firefox中，则改成：
function onMenuClick(evt){  
    if(evt == null)  
    evt = window.event; // For IE  
    var srcElement = evt.srcElement? evt.srcElement : evt.target;  
    // IE使用srcElement, 而Firefox使用target  
    collapseMenu(srcElement);

9. event.x 与 event.y 问题
在IE 中，event 对象有 x, y 属性，Firefox中没有。
解决方法:
在Firefox中，与event.x 等效的是 event.pageX。但event.pageX IE中没有。
故采用 event.clientX 代替 event.x。在IE 中也有这个变量。
event.clientX 与 event.pageX 有微妙的差别（当整个页面有滚动条的时候），
不过大多数时候是等效的。
如果要完全一样，可以稍麻烦些：
mX = event.x ? event.x : event.pageX;

然后用 mX 代替 event.x

10. 用idName字符串取得对象的问题
在IE中，利用 eval(idName) 可以取得 id 为 idName 的 HTML 对象，在Firefox中不能。
解决办法:用 getElementById(idName) 代替 eval(idName).

14. nodeName 和 tagName 问题
在Firefox中，所有节点均有 nodeName 值，但 textNode 没有 tagName 值。
在IE中nodeName 的使用有时会有问题。
解决方法：
使用 tagName，但应检测其是否为空。

15. input的type属性
IE下 input.type属性为只读，但是Firefox下可以修改.

16. 自定义属性
在mf中，自己定义的属性必须getAttribute()取得
而IE可以直接通过"."运算符获取.

17.const 问题
在 IE 中不能使用 const 关键字。如
const constVar = 32;
在IE中这是语法错误.
解决方法:
不使用 const ，以 var 代替.

18. body 对象
Firefox的body在body标签没有被浏览器完全读入之前就存在，而IE则必须在body完全被读入之后才存在.

19. img对象alt和title的解析
alt：当照片不存在或者load错误时的提示,
title：照片的tip说明,
在IE中如果没有定义title，alt也可以作为img的tip使用，但是在Firefox中，两者完全按照标准中的定义使用
在定义img对象时，最好将alt和title对象都写全，保证在各种浏览器中都能正常使用

20.childNodes获取的节点
childNodes的下标的含义在IE和Firefox中不同，Firefox使用DOM规范，childNodes中会插入空白文本节点。
获取子节点时,一般可以通过node.getElementsByTagName()来回避这个问题。

21.removeNode()
Firefox中节点没有removeNode方法，必须使用如下方法
node.parentNode.removeChild(node);

22.innerText
IE支持，FIREFOX不支持
FF中设置内容文本是用textConent属性.

23. XMLHTTP的区别
FireFox中的创建方法为:
xmlhttp=new XMLHttpRequest()  

而在IE中为:
xmlhttp=new ActiveXObject(”Microsoft.XMLHTTP”)

24. img的src刷新问题
在IE 下可以用 可以刷新图片，但在FireFox下不行。主要是缓存问题，在地址后面加个随机数就解决了:
myImg.src=this.src+’?'+Math.random();

25. setAttribute()设置属性问题
IE中很多属性都不能用setAttribute进行设置,但Firefox中却可以,如:
theDiv.setAttribute('style','color:red');  
//改为:  
object.style.cssText = 'color:red;';  
  
  
setAttribute('class','styleClass')  
//改为:  
setAttribute('className','styleClass');  
  
  
obj.setAttribute('onclick','funcitonname();');  
//改为:  
obj.onclick=function(){fucntionname();};  

...等等

-----------------------------------------------------------------------------------------

IE和FIREFOX在解析CSS方面的区别

1. 对高度的解析
IE：将根据内容的高度变化，包括未定义高度的图片内容，即使定义了高度，当内容超过高度时，将使用实际高度
Firefox：没有定义高度时，如果内容中包括了图片内容，Firefox的高度解析是根据印刷标准，这样就会造成和实际内容高度不符合的情况；当定义了高度，但是内容超过高度时，内容会超出定义的高度，但是区域使用的样式不会变化，造成样式错位。
结论：大家在可以确定内容高度的情况下最好定义高度，如果真的没有办法定义高度，最好不用使用边框样式，否则样式肯定会出现混乱！


3.布局问题
当你在写css的时候，特别是用float: left（或right）排列一窜图片时，会发现在firefox里面正常而IE里面有问题。无论你用margin:0,还是border: 0来约束，都无济于事。
其实这里还有另外一个问题，就是IE对于空格的处理，firefox是忽略的而IE对于块与块之间的空格是处理的。也就是说一个div结束后要紧接着一个div写，中间不要有回车或者空格。不然也许会有问题，比如3px的偏差，而且这个原因很难发现。
非常不走运的是我又碰到了这样的问题，多个img标签连着，然后定义的float: left，希望这些图片可以连起来。但是结果在firefox里面正常而IE里面显示的每个img都相隔了3px。我把标签之间的空格都删除都没有作用。
后来的解决方法是在img外面套li，并且对li定义margin: 0，这样就解决了IE和firefox的显示偏差。IE对于一些模型的解释会产生很多错误问题，只有多多尝试才能发现原因。
这只是一些简单的区别,在做布局和CSS设计时候可以综合考虑,但最为有效与简单的解决兼容问题还是用TABLE表格,表格在兼容性方面有着不错的表现.


4.鼠标样式
firefox不支持hand，但ie支持pointer
解决方法: 统一使用pointer

5. padding 问题
padding 5px 4px 3px 1px FireFox无法解释简写,
必须改成 padding-top:5px; padding-right:4px; padding-bottom:3px; padding-left:1px;

6. 消除ul、ol等列表的缩进
消除ul、ol等列表的缩进样式应写成:list-style:none;margin:0px;padding:0px;
其中margin属性对IE有效，padding属性对FireFox有效

7. CSS透明
IE：filter:progid:DXImageTransform.Microsoft.Alpha(style=0,opacity=60)。
FF：opacity:0.6。

8. CSS圆角
IE：不支持圆角。
FF： -moz-border-radius:4px，或者
-moz-border-radius-topleft:4px;
-moz-border-radius-topright:4px;
-moz-border-radius-bottomleft:4px;
-moz-border-radius- bottomright:4px;。

9. CSS双线凹凸边框
IE：border:2px outset;。
FF：
-moz-border-top-colors: #d4d0c8 white;
-moz-border-left-colors: #d4d0c8 white;
-moz-border-right-colors:#404040 #808080;
-moz-border-bottom-colors:#404040 #808080;

10. 滤镜
IE中支持使用滤镜,而Firefox中不支持.

11. 禁止选取网页内容：
在IE中一般用js：obj.onselectstart=function(){return false;};
而firefox用CSS:-moz-user-select:none;
-----------------------------------------------------------------------------------------
由ham利用google收集整理.如果还有更好的相关资源,欢迎分享.

若还有其它IE与FF不同的地方,或者代码中有什么不正确的地方,欢迎指出,我会及时更正.
Tags - , , , , ]]> http://zhoujin.com/post/87/ <![CDATA[JSP内置对象(9个常用的内置对象) ]]> chirs <> Fri, 02 May 2008 03:17:23 +0000 http://zhoujin.com/post/87/
1.request对象

客户端的请求信息被封装在request对象中，通过它才能了解到客户的需求，然后做出响应。它是HttpServletRequest类的实例。

序号 方 法 说 明

1 object getAttribute(String name) 返回指定属性的属性值

2 Enumeration getAttributeNames() 返回所有可用属性名的枚举

3 String getCharacterEncoding() 返回字符编码方式

4 int getContentLength() 返回请求体的长度（以字节数）

5 String getContentType() 得到请求体的MIME类型

6 ServletInputStream getInputStream() 得到请求体中一行的二进制流

7 String getParameter(String name) 返回name指定参数的参数值

8 Enumeration getParameterNames() 返回可用参数名的枚举

9 String[] getParameterValues(String name) 返回包含参数name的所有值的数组

10 String getProtocol() 返回请求用的协议类型及版本号

11 String getScheme() 返回请求用的计划名,如:http.https及ftp等

12 String getServerName() 返回接受请求的服务器主机名

13 int getServerPort() 返回服务器接受此请求所用的端口号

14 BufferedReader getReader() 返回解码过了的请求体

15 String getRemoteAddr() 返回发送此请求的客户端IP地址

16 String getRemoteHost() 返回发送此请求的客户端主机名

17 void setAttribute(String key,Object obj) 设置属性的属性值

18 String getRealPath(String path) 返回一虚拟路径的真实路径

2.response对象

response对象包含了响应客户请求的有关信息，但在JSP中很少直接用到它。它是HttpServletResponse类的实例。

序号 方 法 说 明

1 String getCharacterEncoding() 返回响应用的是何种字符编码

2 ServletOutputStream getOutputStream() 返回响应的一个二进制输出流

3 PrintWriter getWriter() 返回可以向客户端输出字符的一个对象

4 void setContentLength(int len) 设置响应头长度

5 void setContentType(String type) 设置响应的MIME类型

6 sendRedirect(java.lang.String location) 重新定向客户端的请求

　
3.session对象

session对象指的是客户端与服务器的一次会话，从客户连到服务器的一个WebApplication开始，直到客户端与服务器断开连接为止。它是HttpSession类的实例.

序号 方 法 说 明

1 long getCreationTime() 返回SESSION创建时间

2 public String getId() 返回SESSION创建时JSP引擎为它设的惟一ID号

3 long getLastAccessedTime() 返回此SESSION里客户端最近一次请求时间

4 int getMaxInactiveInterval() 返回两次请求间隔多长时间此SESSION被取消(ms)

5 String[] getValueNames() 返回一个包含此SESSION中所有可用属性的数组

6 void invalidate() 取消SESSION，使SESSION不可用

7 boolean isNew() 返回服务器创建的一个SESSION,客户端是否已经加入

8 void removeValue(String name) 删除SESSION中指定的属性

9 void setMaxInactiveInterval() 设置两次请求间隔多长时间此SESSION被取消(ms)

4.out对象

out对象是JspWriter类的实例,是向客户端输出内容常用的对象

序号 方 法 说 明

1 void clear() 清除缓冲区的内容

2 void clearBuffer() 清除缓冲区的当前内容

3 void flush() 清空流

4 int getBufferSize() 返回缓冲区以字节数的大小，如不设缓冲区则为0

5 int getRemaining() 返回缓冲区还剩余多少可用

6 boolean isAutoFlush() 返回缓冲区满时，是自动清空还是抛出异常

7 void close() 关闭输出流

5.page对象

page对象就是指向当前JSP页面本身，有点象类中的this指针，它是java.lang.Object类的实例

序号 方 法 说 明

1 class getClass 返回此Object的类

2 int hashCode() 返回此Object的hash码

3 boolean equals(Object obj) 判断此Object是否与指定的Object对象相等

4 void copy(Object obj) 把此Object拷贝到指定的Object对象中

5 Object clone() 克隆此Object对象

6 String toString() 把此Object对象转换成String类的对象

7 void notify() 唤醒一个等待的线程

8 void notifyAll() 唤醒所有等待的线程

9 void wait(int timeout) 使一个线程处于等待直到timeout结束或被唤醒

10 void wait() 使一个线程处于等待直到被唤醒

11 void enterMonitor() 对Object加锁

12 void exitMonitor() 对Object开锁



6.application对象


application对象实现了用户间数据的共享，可存放全局变量。它开始于服务器的启动，直到服务器的关闭，在此期间，此对象将一直存在；这样在用户的前后连接或不同用户之间的连接中，可以对此对象的同一属性进行操作；在任何地方对此对象属性的操作，都将影响到其他用户对此的访问。服务器的启动和关闭决定了application对象的生命。它是ServletContext类的实例。


序号 方 法 说 明

1 Object getAttribute(String name) 返回给定名的属性值

2 Enumeration getAttributeNames() 返回所有可用属性名的枚举

3 void setAttribute(String name,Object obj) 设定属性的属性值

4 void removeAttribute(String name) 删除一属性及其属性值

5 String getServerInfo() 返回JSP(SERVLET)引擎名及版本号

6 String getRealPath(String path) 返回一虚拟路径的真实路径

7 ServletContext getContext(String uripath) 返回指定WebApplication的application对象

8 int getMajorVersion() 返回服务器支持的Servlet API的最大版本号

9 int getMinorVersion() 返回服务器支持的Servlet API的最大版本号

10 String getMimeType(String file) 返回指定文件的MIME类型

11 URL getResource(String path) 返回指定资源(文件及目录)的URL路径

12 InputStream getResourceAsStream(String path) 返回指定资源的输入流

13 RequestDispatcher getRequestDispatcher(String uripath) 返回指定资源的RequestDispatcher对象

14 Servlet getServlet(String name) 返回指定名的Servlet

15 Enumeration getServlets() 返回所有Servlet的枚举

16 Enumeration getServletNames() 返回所有Servlet名的枚举

17 void log(String msg) 把指定消息写入Servlet的日志文件

18 void log(Exception exception,String msg) 把指定异常的栈轨迹及错误消息写入Servlet的日志文件

19 void log(String msg,Throwable throwable) 把栈轨迹及给出的Throwable异常的说明信息 写入Servlet的日志文件

7.exception对象


exception对象是一个例外对象，当一个页面在运行过程中发生了例外，就产生这个对象。如果一个JSP页面要应用此对象，就必须把isErrorPage设为true，否则无法编译。他实际上是java.lang.Throwable的对象


序号 方 法 说 明

1 String getMessage() 返回描述异常的消息

2 String toString() 返回关于异常的简短描述消息

3 void printStackTrace() 显示异常及其栈轨迹

4 Throwable FillInStackTrace() 重写异常的执行栈轨迹



8.pageContext对象


pageContext对象提供了对JSP页面内所有的对象及名字空间的访问，也就是说他可以访问到本页所在的SESSION，也可以取本页面所在的application的某一属性值，他相当于页面中所有功能的集大成者，它的本类名也叫pageContext。


序号 方 法 说 明

1 JspWriter getOut() 返回当前客户端响应被使用的JspWriter流(out)

2 HttpSession getSession() 返回当前页中的HttpSession对象(session)

3 Object getPage() 返回当前页的Object对象(page)

4 ServletRequest getRequest() 返回当前页的ServletRequest对象(request)

5 ServletResponse getResponse() 返回当前页的ServletResponse对象(response)

6 Exception getException() 返回当前页的Exception对象(exception)

7 ServletConfig getServletConfig() 返回当前页的ServletConfig对象(config)

8 ServletContext getServletContext() 返回当前页的ServletContext对象(application)

9 void setAttribute(String name,Object attribute) 设置属性及属性值

10 void setAttribute(String name,Object obj,int scope) 在指定范围内设置属性及属性值

11 public Object getAttribute(String name) 取属性的值

12 Object getAttribute(String name,int scope) 在指定范围内取属性的值

13 public Object findAttribute(String name) 寻找一属性,返回起属性值或NULL

14 void removeAttribute(String name) 删除某属性

15 void removeAttribute(String name,int scope) 在指定范围删除某属性

16 int getAttributeScope(String name) 返回某属性的作用范围

17 Enumeration getAttributeNamesInScope(int scope) 返回指定范围内可用的属性名枚举

18 void release() 释放pageContext所占用的资源

19 void forward(String relativeUrlPath) 使当前页面重导到另一页面

20 void include(String relativeUrlPath) 在当前位置包含另一文件


9.config对象


config对象是在一个Servlet初始化时，JSP引擎向它传递信息用的，此信息包括Servlet初始化时所要用到的参数（通过属性名和属性值构成）以及服务器的有关信息（通过传递一个ServletContext对象）


序号 方 法 说 明

1 ServletContext getServletContext() 返回含有服务器相关信息的ServletContext对象

2 String getInitParameter(String name) 返回初始化参数的值

3 Enumeration getInitParameterNames() 返回Servlet初始化所需所有参数的枚举
Tags - , , , , , , , , ]]> http://zhoujin.com/post/86/ <![CDATA[JSP动作指令(6个常用的动作指令)]]> chirs <> Thu, 01 May 2008 03:16:18 +0000 http://zhoujin.com/post/86/ 一、Include指令
<jsp:include>标签表示包含一个静态的或者动态的文件。
语法：
<jsp:include page="path" flush="true" />
or
<jsp:include page="path" flush="true"><jsp:param name="paramName" value="paramValue" /></jsp:include>
注：
1、page="path" 为相对路径，或者代表相对路径的表达式。
2、flush="true" 必须使用flush为true，它默认值是false。
3、<jsp:param>子句能让你传递一个或多个参数给动态文件，也可在一个页面中使用多个<jsp:param>来传递多个参数给动态文件。

二、Forward指令
<jsp:forward>标签表示重定向一个静态html/jsp的文件，或者是一个程序段。
语法：
<jsp:forward page="path"/>
or
<jsp:forward page="path">
   <jsp:param name="paramName" value="paramValue" />
   ….
</jsp:forward>
注：
1、page="path" 为一个表达式，或者一个字符串。
2、<jsp:param> name 指定参数名，value指定参数值。参数被发送到一个动态文件，参数可以是一个或多个值，而这个文件却必须是动态文件。要传递多个参数，则可以在一个JSP文件中使用多个<jsp:param>将多个参数发送到一个动态文件中。

三、UseBean指令
<jsp:useBean>标签表示用来在JSP页面中创建一个BEAN实例并指定它的名字以及作用范围。
语法：
<jsp:useBean id="name" scope="page | request | session | application" typeSpec />
其中typeSpec有以下几种可能的情况:
class="className" | class="className" type="typeName" |beanName="beanName" type="typeName" |type="typeName" |
注： 你必须使用class或type，而不能同时使用class和beanName。beanName表示Bean的名字，其形式为“a.b.c”。

四、GetProperty指令
<jsp:getProperty>标签表示获取BEAN的属性的值并将之转化为一个字符串，然后将其插入到输出的页面中。
语法：
<jsp:getProperty name="name" property="propertyName" />
注：
1、在使用<jsp:getProperty>之前，必须用<jsp:useBean>来创建它。
2、不能使用<jsp:getProperty>来检索一个已经被索引了的属性。
3、能够和JavaBeans组件一起使用<jsp:getProperty>，但是不能与Enterprise Java Bean一起使用。

五、SetProperty指令
<jsp:setProperty>标签表示用来设置Bean中的属性值。
语法：
<jsp:setProperty name="beanName" prop_expr />
其中prop_expr有以下几种可能的情形：
property="*" | property="propertyName" | property="propertyName" param="parameterName" |property="propertyName" value="propertyValue"
注： 使用 jsp:setProperty 来为一个Bean的属性赋值；可以使用两种方式来实现。
1、在jsp:useBean后使用jsp:setProperty：
<jsp:useBean id="myUser" … />
…
<jsp:setProperty name="user" property="user" … />
在这种方式中，jsp:setProperty将被执行。
2、jsp:setProperty出现在jsp:useBean标签内：
<jsp:useBean id="myUser" … >
 …
 <jsp:setProperty name="user" property="user" … />
</jsp:useBean>
在这种方式中，jsp:setProperty只会在新的对象被实例化时才将被执行。
* 在<jsp:setProperty>中的name值应当和<jsp:useBean>中的id值相同。

六、Plugin指令
<jsp:plugin>标签表示执行一个applet或Bean，有可能的话还要下载一个Java插件用于执行它。
语法：
<jsp:plugin
type="bean | applet"
code="classFileName"
codebase="classFileDirectoryName"
[ name="instanceName" ]
[ archive="URIToArchive, ..." ]
[ align="bottom | top | middle | left | right" ]
[ height="displayPixels" ]
[ width="displayPixels" ]
[ hspace="leftRightPixels" ]
[ vspace="topBottomPixels" ]
[ jreversion="JREVersionNumber | 1.1" ]
[ nspluginurl="URLToPlugin" ]
[ iepluginurl="URLToPlugin" ] >
[ <jsp:params>
[ <jsp:param name="parameterName" value="{parameterValue | <%= expression %>}" /> ]+
</jsp:params> ]
[ <jsp:fallback> text message for user </jsp:fallback> ]
</jsp:plugin>
注：
<jsp:plugin>元素用于在浏览器中播放或显示一个对象（典型的就是applet和Bean),而这种显示需要在浏览器的java插件。
当Jsp文件被编译，送往浏览器时，<jsp:plugin>元素将会根据浏览器的版本替换成<object>或者<embed>元素。注意，<object>用于HTML 4.0 ，<embed>用于HTML 3.2。
一般来说，<jsp:plugin>元素会指定对象是Applet还是Bean,同样也会指定class的名字，还有位置，另外还会指定将从哪里下载这个Java插件。


Tags - , ]]> http://zhoujin.com/post/74/ <![CDATA[Birt 2.2与struts 1.3.9整合]]> chirs <> Sat, 05 Apr 2008 11:33:10 +0000 http://zhoujin.com/post/74/ 1.去www.eclipse.org/birt/上下载birt-runtime-2_2_0.zip

2.在%WEB_APP%/WEB-INF/下新建一文件夹"platform""

3.把刚下载的birt-runtime-2_2_0.zip包中的ReportEngine目录下的"configuration"和"plugins"复制到%WEB_APP%/WEB-INF/platform/下

4.把ReportEngine目录下的"lib"里面的jar文件复制到%WEB_APP%/WEB-INF/lib/下面

5.对ActionServlet进行扩展

/**
* 对Struts进行扩展，实现Hibernate的初始化以及参数编码的自动处理
*
* @author [email]chirs@zhoujin.com[/email]
*/
public class FreeOCS_ActionServlet extends ActionServlet {

    private static final long serialVersionUID = 1L;
    private String encoding;
    public void init() throws ServletException {
        ServletContext context = getServletContext();
        if (Globals.WEBAPP_PATH == null) Globals.WEBAPP_PATH = context.getRealPath("");
        // 初始化系统安全控制
        try {
            KukeSecurityManager.init(context);
        } catch (IOException e) {
            throw new ServletException(e);
        }
        // 执行Struts的初始化过程
        super.init();
        BirtEngine.initBirtConfig();
        encoding = getInitParameter("encoding");
        if (encoding == null) encoding = Globals.ENC_UTF_8;
    }

    /**
     * 实现对编码的自动转码处理
     *
     * @param req
     * @param res
     * @throws ServletException
     * @throws IOException
     * @see org.apache.struts.action.ActionServlet#process(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
     */
    protected void process(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {

        HttpServletRequest request;
        if (RequestUtils.isMultipart(req)) {
            // 文件表单的编码处理
            request = req;
            request.setCharacterEncoding(encoding);
        } else {
            // 自动编码处理
            String enc = req.getCharacterEncoding();
            if (req instanceof RequestProxy) request = req;
            else if (encoding.equalsIgnoreCase(enc)) request = req;
            else request = new RequestProxy(req, encoding);
        }
        super.process(request, res);
    }

    public void destroy() {
        // 释放Struts
        super.destroy();
        BirtEngine.destroyBirtEngine();
    }
}

6.BirtEngine.java
public class BirtEngine {
    private static IReportEngine birtEngine = null;
    private static Properties configProps = new Properties();
    private final static String configFile = "ReportConfig.properties";

    public static synchronized void initBirtConfig() {
        loadEngineProps();
    }

    public static synchronized IReportEngine getBirtEngine(ServletContext sc) {
        if (birtEngine == null) {
            EngineConfig config = new EngineConfig();
            if (configProps != null) {
                String logLevel = configProps.getProperty("logLevel");
                Level level = Level.OFF;
                if ("SEVERE".equalsIgnoreCase(logLevel)) {
                    level = Level.SEVERE;
                } else if ("WARNING".equalsIgnoreCase(logLevel)) {
                    level = Level.WARNING;
                } else if ("INFO".equalsIgnoreCase(logLevel)) {
                    level = Level.INFO;
                } else if ("CONFIG".equalsIgnoreCase(logLevel)) {
                    level = Level.CONFIG;
                } else if ("FINE".equalsIgnoreCase(logLevel)) {
                    level = Level.FINE;
                } else if ("FINER".equalsIgnoreCase(logLevel)) {
                    level = Level.FINER;
                } else if ("FINEST".equalsIgnoreCase(logLevel)) {
                    level = Level.FINEST;
                } else if ("OFF".equalsIgnoreCase(logLevel)) {
                    level = Level.OFF;
                }
                config.setLogConfig(configProps.getProperty("logDirectory"), level);
            }
            config.setEngineHome("");
            IPlatformContext context = new PlatformServletContext(sc);
            config.setPlatformContext(context);
            try {
                Platform.startup(config);
            } catch (BirtException e) {
                e.printStackTrace();
            }

            IReportEngineFactory factory = (IReportEngineFactory) Platform.createFactoryObject(IReportEngineFactory.EXTENSION_REPORT_ENGINE_FACTORY);
            birtEngine = factory.createReportEngine(config);

        }
        return birtEngine;
    }

    public static synchronized void destroyBirtEngine() {
        if (birtEngine == null) { return; }
        birtEngine.destroy();
        Platform.shutdown();
        birtEngine = null;
    }

    public Object clone() throws CloneNotSupportedException {
        throw new CloneNotSupportedException();
    }

    private static void loadEngineProps() {
        try {
            // Config File must be in classpath
            ClassLoader cl = Thread.currentThread().getContextClassLoader();
            InputStream in = null;
            in = cl.getResourceAsStream(configFile);
            configProps.load(in);
            in.close();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

7.ActionBase.java
/**
* *
* @author [email]chirs@zhoujin.com[/email]
*/
public abstract class ActionBase extends Action {
    final static String ISO8859_1 = "8859_1";

    protected static String FORWARD_LIST = "list";
    protected static String FORWARD_CREATE = "create";
    protected static String FORWARD_EDIT = "edit";
    protected static String FORWARD_UPDATE = "update";
    protected static String FORWARD_ERROR = "error";
    protected static String FORWARD_HTMLERROR = "htmlError";
    public final static String METHOD_IDENT_PARAM = "__method";

    protected final Log log = LogFactory.getLog(this.getClass().getName());

    private IReportEngine birtReportEngine = null;
    /**
     * 查询结果列表
     */
    private List resultList;
    /**
     * 设计文件的在web应用中的相对路径,不含context path. eg. /reports/sale_report.rptdesign
     */
    private String designFile = null;

    /**
     * 图片生成目录在web应用中的相对路径,,不含context path eg. "/plugins-demo/birt/sale_report.rptdesign/birt/images
     */
    private String imageDirectory = null;

    private String scriptableJOName = "dsFactory";

    /**
     * 在页面上显示的图片链接,是与请求url的相对路径
     */
    private String baseImageUrl = "images";
    /**
     * 输出格式参数
     */
    private String format = "pdf";
    /**
     * 打开报表设计文件(.rptdesign)
     */
    public void openReportDesign(String file) throws IOException, EngineException {
        designFile = file;
    }
    /**
     * 设置图片目录
     */
    public void setImageDirectory(String imageDirectory) {
        this.imageDirectory = imageDirectory;
    }
    /**
     * 设置图片地址
     */
    public void setBaseImageUrl(String baseImageUrl) {
        this.baseImageUrl = baseImageUrl;
    }
    /**
     * 设置报表输出格式
     */
    public void setFormat(String format) {
        this.format = format;
    }
    public void setScriptableJOName(String scriptableJOName) {
        this.scriptableJOName = scriptableJOName;
    }
    /**
     * 放入查询结果数据
     */
    public void putModel(List list) {
        resultList = list;
    }

    protected ServletContext context() {
        return servlet.getServletContext();
    }

    protected ServletConfig config() {
        return servlet.getServletConfig();
    }
    /**
     * birt 运行
     */
    @SuppressWarnings("deprecation")
    protected void outputReport(HttpServletRequest request, HttpServletResponse response) throws IOException {
        if (format == null || format.equalsIgnoreCase("html")) {
            response.setContentType("text/html");// 用HTML方式显示
        } else {
            response.setContentType("application/pdf");
            // response.setHeader("Content-Disposition", "inline; filename=test.pdf");
            response.setHeader("Content-Disposition", "attachment; filename=test.pdf");// 下载
        }
        ServletContext sc = request.getSession().getServletContext();
        birtReportEngine = BirtEngine.getBirtEngine(sc);

        IReportRunnable design;
        try {
            // Open report design
            design = birtReportEngine.openReportDesign(sc.getRealPath("/reports") + "/" + designFile);
            // create task to run and render report
            IRunAndRenderTask task = birtReportEngine.createRunAndRenderTask(design);
            BirtDataSourceObject birtDataSourceObject = new BirtDataSourceObject();
            // 设置输出选项
            HTMLRenderOption options = new HTMLRenderOption();
            birtDataSourceObject.setResultList(resultList);
            options.setBaseImageURL(request.getContextPath() + imageDirectory);
            options.setImageDirectory(sc.getRealPath(baseImageUrl));

            if (format == null || format.equalsIgnoreCase("html")) {
                response.setContentType("text/html");// 用HTML方式显示
                options.setOutputFormat(HTMLRenderOption.OUTPUT_FORMAT_HTML);// HTML
            } else {
                options.setOutputFormat(HTMLRenderOption.OUTPUT_FORMAT_PDF);// PDF
            }
            options.setOutputStream(response.getOutputStream());
            task.setRenderOption(options);
            task.addScriptableJavaObject(scriptableJOName, birtDataSourceObject);
            // run report
            task.run();
            task.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

8.BirtDataSourceObject.java
/**
*
* @author [email]chirs@zhoujin.com[/email]
*/
public class BirtDataSourceObject {
    private List resultList = new ArrayList();

    public List getResultList() {
        return resultList;
    }

    public void setResultList(List resultList) {
        this.resultList = resultList;
    }
}



测试：
1.BaseTestListAction.java
public class BaseTestListAction extends ActionBase {
public ActionForward doExecute(ActionMapping mapping, ActionForm actionForm, HttpServletRequest request, HttpServletResponse response) throws Exception {
        this.setFormat("pdf");
        this.openReportDesign("test.rptdesign");
        List<ViewListBean> list=new ArrayList<ViewListBean>();
        ViewListBean oa=new ViewListBean();
        oa.setAnnexa("测试1");
        oa.setAnnexb("测试2");
        oa.setAnnexc("测试3");
        list.add(oa);
        ViewListBean ob=new ViewListBean();
        ob.setAnnexa("测试4");
        ob.setAnnexb("测试5");
        ob.setAnnexc("测试6");
        list.add(ob);
        ViewListBean oc=new ViewListBean();
        oc.setAnnexa("测试7");
        oc.setAnnexb("测试8");
        oa.setAnnexc("测试9");
        list.add(oc);
        this.putModel(list);
        outputReport(request,response);
        return null;
    }
}

2.在open中输入
rtn = dsFactory.getResultList();
totalrows = rtn.size();
currentrow=0;

3.在fetch中输入
if(currentrow >= totalrows){
return false;
}
row["annexa"] = rtn.get(currentrow).getAnnexa();
row["annexb"] = rtn.get(currentrow).getAnnexb();
row["annexc"] = rtn.get(currentrow).getAnnexb();
currentrow++;
return true;

4.在close中输入
rtn = null;

Tags - , , , ]]> http://zhoujin.com/post/72/ <![CDATA[简简单单的感觉]]> chirs <> Sat, 15 Mar 2008 10:39:26 +0000 http://zhoujin.com/post/72/
因为比较得到的,或是骄傲自豪,或是黯然伤神,更根本的不好点是:很容易让人迷失了自我,忘记了自己真正想要的东西!!!

但是,人就是在这种比较中长大成熟,找到自己真正想要的东西的!!因为人,就是生活在环境中的!!!!

很高兴换来的是别人的嫉妒,JIAOJIAO的骄傲感觉!哈哈 被幸福包围的感觉,飘飘欲仙的感觉,还被幸福冲昏的头脑~~~~~~~~

其实很简单,简简单单的感觉,真实而平华..
Tags - , ]]> http://zhoujin.com/post/75/ <![CDATA[有关Servlet Example在2.2版本中使用]]> chirs <> Wed, 05 Mar 2008 02:31:36 +0000 http://zhoujin.com/post/75/
//setup image directory
HTMLRenderContext renderContext = new HTMLRenderContext();
renderContext.setBaseImageURL(req.getContextPath()+"/images");
renderContext.setImageDirectory(sc.getRealPath("/images"));

logger.log( Level.FINE, "image directory " + sc.getRealPath("/images"));  
System.out.println("stdout image directory " + sc.getRealPath("/images"));

HashMap<String, HTMLRenderContext> contextMap = new HashMap<String, HTMLRenderContext>();
contextMap.put( EngineConstants.APPCONTEXT_HTML_RENDER_CONTEXT, renderContext );

task.setAppContext( contextMap );

会提示不建议使用的类和方法之类，建议的用法是
//setup image directory
options.setBaseImageURL(req.getContextPath() + "/images");
options.setImageDirectory(sc.getRealPath("/images"));

原来的方法全部去掉

另外我遇到一个还没有找到解决的办法
task.addScriptableJavaObject(...);

Tags - , , ]]> http://zhoujin.com/post/71/ <![CDATA[拂过]]> chirs <> Thu, 14 Feb 2008 10:38:04 +0000 http://zhoujin.com/post/71/ 打开窗，一丝一缕，然后是阵阵轻舞的风，风拂过，记忆会如蓓蕾慢慢绽开。
于是，我会站立在风中，顺着风的方向遥望已逝的韶光，回忆过去的点点滴滴。这一年又从指间溜走了，如黄沙，流水般，我，拥有了什么？

我已学会告诉自己：有时失去是一种拥有，有时跌倒是一份财富。宁静致远，洗却浮躁与不安。既不忘乎所以又能泰然处之；既不囿于寂寞忧郁又能望眼欲穿。
夹着寒意的风啊，轻柔地拂过我的心，如拂尘般拂去我心中一年的灰尘……风的尽头是什么？


Tags - ]]> http://zhoujin.com/post/70/ <![CDATA[随想]]> chirs <> Fri, 25 Jan 2008 10:35:52 +0000 http://zhoujin.com/post/70/ 每个人在内心里可能都曾经有过一段刻骨铭心的爱恋纠缠，爱有多重伤就有多痛。也许只有经过岁月的洗礼，过往的伤痛才会痊愈结痂，变成我们胸口的一粒朱砂，心头的一块烙印，记忆里的一枚印章，那么我们只能审视自己，正视过去，过去的伤痛才永远不能阻隔你的将来！
我们会与很多人遇见，但只有少数人能拨动我们的心弦，有些人会在特定的时间出现，有些人会在一定的时间消失，结局谁也无法预测，但我们至少可以把握现在.
 
试去尘埃，让过去的一切变成一盏灯，让它照亮我们幸福的将来，或许，属于你我的那枚爱情果就在不远的将来，它会忠于幸福。。。。。。。。。。

Tags - , , , ]]> http://zhoujin.com/post/69/ <![CDATA[2007年这一年]]> chirs <> Mon, 31 Dec 2007 15:59:59 +0000 http://zhoujin.com/post/69/ 2007年的最后一小时，看样子不会再有什么奇迹在我身上发生，就此作罢，粗略盘点一下：

这一年，工作一年，简直就成了一个空中飞人了，不停的出差；

这一年，认识了一些人，结交了几个新朋友，虽然老朋友们中尚未出现弃我而去的现象，但对于世事无常和人情冷暖的感慨却一再涌上心头；

这一年，依然怀着周游世界的梦想，但实际上只到过一次黄果树；

这一年，曾经列了阅读的计划，庞杂的书目反映了对知识的狂热渴求，但执行的不力又充分说明这狂热会迅速退烧；

这一年，购置了一处豪宅，日后的幸福生活有了全新的屋檐，但也为之高筑债台，估计银行会不停追讨超过30年；

这一年，重新变回了网虫，主要的原因是在很长一段时间里我都在学习当中；

这一年，第一个属于自己的技术框架基本上上完成了;

这一年，对于自己有一个很明确的技术目标！

这一年，被自己重新认识，惊讶地发现居然还存在着坚强与乐观的品格，但也失望地看到许多不足无力弥补，最大一个就是无论怎么进补也改变不了身材的瘦削；

这一年，缺席了一个同学会，但重新联系上的同学预计会很不少；

这一年，很多的想法破灭，又有很多想法发生，这些还没来得及破灭的想法只有留待来年……


Tags - , ]]> http://zhoujin.com/post/76/ <![CDATA[谢谢你]]> chirs <> Tue, 30 Oct 2007 07:08:25 +0000 http://zhoujin.com/post/76/ --我虽然会因为听到这样的话而感受到心痛。可是看见你现在幸福的样子，我也真的觉得很幸福。
--以前我每次听到都会不悄的歌曲，那天也让我流泪了。那首歌叫《很爱很爱你》。 ]]> http://zhoujin.com/post/68/ <![CDATA[话说技术含量？]]> chirs <> Tue, 23 Oct 2007 14:07:13 +0000 http://zhoujin.com/post/68/ 　　前天在吃午饭时，跟同事突然说起弹吉他的事情，不知怎么说到谈得不好的人就跟弹棉花一样。我却不大乐意，反问一句：你见过弹棉花没？他摇头。我就跟他解释如何弹棉花，解释弹棉花的韵律和美感。他依然一头雾水，却最终同意弹棉花也并非意味着毫无技术含量。

　　记得小时候，在一个比被子稍大的房间，任何一个弹花匠都可以踩着四四拍，三下闷音一下长音或者两短一长一短，几小时内弹出一床厚厚的棉被来。


Tags - , ]]> http://zhoujin.com/post/80/ <![CDATA[如何自定义事件]]> chirs <> Fri, 03 Aug 2007 07:41:06 +0000 http://zhoujin.com/post/80/
RequestContext.getContext().getSession()

　　等操作来获取服务器状态信息，最常见的就是在很多OA应用中，绝大部分操作都需要用户登录才能使用。这种场景的常见处理办法是先判断用户是否登录，然后再调用某­些方法。例如，一个列出用户所有的文档：
buffalo.remoteCall("userService.isLogin", [], function(reply) {
　if (reply.getResult()) {
      　buffalo.remoteCall("bookService.listAllBooks", [], function(reply){ ... })
  　} else {
    　　alert("请先登录")
  　}
})

　　如果只有一两个这样的案例还好，如果多起来的话，会显得相当麻烦。实际上buffalo已经支持了自定义事件。在spring的拦截器的帮助下，可以实现编程的­简化，以及一致性的错误控制。
　　实现方式：
　　１.编写一个spring 拦截器，将其配置到需要进行拦截的服务中，其中代码片段如下：

public class RequiredLoginInterceptor implements MehtodInterceptor {
　　public Object invoke(MethodInvocation invoke) ...{
   　　　String username = RequestContext.getSession().get("username");
   　　　 　if (username == null) {
        　　　　throw new RequiredLoginException("Please login first!");
   　　　 　}
    　　　　return invoke.proceed();
　　　 　}
}

　　２.在客户端需要调用的地方，重写onException方法：

var buffalo = new ...
buffalo.events["onException"] = function(fault) {
　　if (fault.code == "your.domain.RequiredLoginException") {
    　　alert("请先登录！");
    　　//或者其他处理
　　 }
}


　　这样写完之后，所有出现exception的地方都会被这个方法来调用。因此本文开头的案例可以直接写为：

buffalo.remoteCall("bookService.listAllBooks", [], function(reply){ ... })


　　当需要集中处理某一类的异常的时候，这是一种相当简单的做法。buffalo已经提供了这个支持。
补spring配置方式:

<bean id="requiredLogin" class="your.domain.RequiredLoginInterceptor"/>
  <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">    
    <property name="beanNames">    
      <list>
        <!-- 在这里可以声明多个需要拦截的bean　-->
        <value>...</value>
      </list>    
    </property>    
    <property name="interceptorNames">    
      <list>    
        <value>requiredLogin</value>  <!-- 同样，在这里可以声明多个拦截器，注意次序前后　-->  
      </list>    
  </property>    
</bean>

Tags - , , , , , ]]> http://zhoujin.com/post/79/ <![CDATA[API 参考]]> chirs <> Tue, 03 Jul 2007 07:38:39 +0000 http://zhoujin.com/post/79/ 类Buffalo

在一般的情况下，Buffalo类可以解决大多数的问题

Buffalo(gateway, async, events, options)

参数名称参数类型参数说明是否必须默认值
gateway string Bufapp Servlet的地址 true N/A
async boolean 是否异步请求 false true
events object 待响应的事件 false 参见 如何自定义事件
options object 其他选项 false timeout=10000


Buffalo类的构造方法示例：

var buffalo = new Buffalo("/bfapp/buffalo");

发送一个异步请求: 

var buffalo = new Buffalo("/bfapp/buffalo", false);


remoteCall(service, params, callback)

remoteCall 会封装所有指定的参数来远程调用指定的服务，并且用回调方法处理结果

参数名称参数类型参数说明是否必须默认值
service string 服务的类名和方法名, 格式为 "serviceName.methodName" true N/A
params Array 远程调用的参数 true N/A
callback function 回调方法, 会将 Buffalo.Reply 作为此方法的参数 true N/A

示例：

buffalo.remoteCall("helloService.hello", ['Michael'], function(reply) {     alert(reply.getResult()); })

reply.getResult() 方法会返回几乎和原始定义的Java对象一样的javascript对象

或者: 

buffalo.remoteCall("helloService.hello", ['Michael'], myfunc); function myfunc(reply) {   alert(reply.getResult()); }
  • setEvents(events)

setEvents 会为buffalo实例指定自定义的事件响应方法

参数名称参数类型参数说明是否必须默认值
events object 事件响应 true N/A
buffalo.setEvents({onLoading:myloading}}) function myloading(state) {   if (state) {window.status = "loading..."; }    else {window.status = "load completed."; } }

或者可以直接这样做: 

buffalo.events["onLoading"] = myloading;

bindReply(service, params, elementId)

bindReply 会发送一个远程调用并且把返回的结果绑定指定的HTML元素

参数名称参数类型参数说明是否必须默认值
service string 服务的类名和方法名, 格式为 "serviceName.methodName" true N/A
params Array 远程调用的参数 true N/A
elementId string 要绑定的html元素id true N/A

举个简单例子：调用 simpleService.provincesNames 方法然后把返回的所有"省"绑定在 id=select_provinde的html元素上.
你可以阅读 绑定 获得更多信息. 

buffalo.bindReply("simpleService.provincesNames",[],"select_province");

switchView(viewName)

switchView 会请求指定的 <视图名称> 然后把所有的内容加载到 id=body 的 div 元素中，并且会把此次操作记录在浏览器的历史记录中。从而可以方便地使用浏览器的前进\后退功能

参数名称参数类型参数说明是否必须默认值
viewName string 视图的url true N/A
buffalo.switchView("help.html");

switchPart(viewName, partId, addToHistory)

switchPart 会请求指定的 <视图名称> 然后把所有的内容加载到 id=<指定元素的id> 的元素中，并且可以通过指定 <addToHistory>的参数来决定是否把此次操作记录在浏览器的历史记录中。

参数名称参数类型参数说明是否必须默认值
viewName string 视图的url true N/A
partId string 要替换的div元素的id true N/A
addToHistory boolean 此操作是否加入浏览器历史 true N/A

Tags - , , , , ]]> http://zhoujin.com/post/78/ <![CDATA[绑定]]> chirs <> Sun, 03 Jun 2007 07:17:11 +0000 http://zhoujin.com/post/78/
　　你可以如此轻松地使用绑定：
buffalo.bindReply("yourService.method", [parameters], "elementId")

　　上面的代码片断尝试把"parameters"作为参数调用"yourService.method"，然后绑定调用结果给"elementId"。

　　如果你并不想作远程调用，也可以按下面的方式使用绑定：
Buffalo.Bind.bind(elementId, bindValue)

　　它将绑定"bindValue"到"elementId" 。

　　[注意]：这里无需在意form成员的不同类型。buffalo将检查类型并完成正确的绑定行为。

　　绑定form成员：
　　１.绑定text, hidden, password, textarea
　　　　１.被绑定值的类型:原始类型如：String, int, long, float...
　　　　２.行为:element.value=bindValue
　　２.绑定checkbox, radio
　　　　１.被绑定值的类型: 需要检查值是否为("true"|"yes"|"1"|true|1)
　　　　２.行为: element.checked=bindValue==("true"|"yes"|"1"|true|1)
　　３.绑定select
　　　　１.被绑定值的类型:对象数组（Array of objects）
　　　　２.行为:数组中每个成员（对象）增加一个option，select应用额外的和属性来告诉绑定：对象的字段（field）如何绑定到text/value上。
　　　　３.特殊的必要条件:和属性应该添加到select成员中，来告知select成员对象的字段（field）如何绑定。

<select id="provinces" jtext="name" jvalue="value"></select>

/* Data */
var data = [{name: "Hu Bei", value:"HB"} ,{name: "Shan Xi", value:"SX"}]

/* Binding */
Buffalo.Bind.bind("provinces", data);

当上面的例子执行时，select将增加两个option，option的text为data["name"]，value为data["value"]。
　　绑定表格
　　绑定表格有一些复杂。有3种绑定表格的方式。你需要提供的属性和
的属性。
　　属性告诉buffalo如何复制样式（style），则告诉buffalo绑定值的哪个字段用于显示。

　　１.被绑定值的类型:对象数组（Array of objects）
　　２.行为:因属性值而不同
　　　　１.=0时，它将删除表格的所有行，增加显示对象所有字段的行。
　　　　２.=1时，它将表格的第一行视为表头，删除其余的所有行，增加显示对象[]的行。
　　　　３.=2时，它将表格的第一行视为表头、将第二行视为样式，删除其余的所有行，增加显示对象[]的行。
　　　　４.=3时，它将表格的第一行视为表头、将第二行视为奇数行样式、将第三行视为偶数行样式，删除其余的所有行，增加显示对象[]的行。
　　３.特殊的必要条件:的属性和
的属性。
　　例子:
<table id="table" jheight="0"></table>

　　jheight=0, 表格上将显示出所有的绑定值。

<table id="locales" jheight="1">

<tr bgcolor="#FFCC00">

<td jtext="language">Language</td>

<td width="300" bgcolor="#FFCC00" jtext="country">Country</td>

<td jtext="variant">variant</td>

<td jtext="hashcode">Hashcode</td>

</tr>

</table>

　　jheight=1, buffalo将使用第一行作为表头，显示所有的定义在中的绑定值。

<table id="locales" jheight="2">

<tr bgcolor="#FFCC00">

<td jtext="language">Language</td>

<td width="300" bgcolor="#FFCC00" jtext="country">Country</td>

<td jtext="variant">variant</td>

<td jtext="hashcode">Hashcode</td>

</tr>

<tr bgcolor="#ffff66">

<td>a</td>

<td width="300">d</td>

<td>c</td>

<td>d</td>

</tr>

</table>

　　jheight=2, buffalo将使用第一行作为表头，第二行作为样式，显示所有的定义在中的绑定值。

<table id="locales" jheight="3">

<tr bgcolor="#FFCC00">

<td jtext="language">Language</td>

<td width="300" bgcolor="#FFCC00" jtext="country">Country</td>

<td jtext="variant">variant</td>

<td jtext="hashcode">Hashcode</td>

</tr>

<tr bgcolor="#ffff66">

<td>a</td>

<td width="300">d</td>

<td>c</td>

<td>d</td>

</tr>

<tr bgcolor="#66ff66">

<td>a</td>

<td width="300">d</td>

<td>c</td>

<td>d</td>

</tr>

</table>

　　jheight=3, buffalo将使用第一行作为表头，第二行作为奇数行样式，第三行作为偶数行样式，显示所有的定义在中的绑定值。
　　绑定form
　　Buffalo能直接绑定对象值到form中。
　　１.被绑定值的类型:对象
　　２.行为:当同样的form成员名称存在于对象时，对象的相应值会被绑定到这个form成员上。对于checkbox/多项选择的select，使用数组类型的值去尝试check或select所有的checkbox或所有option。
　　 示例:

/* Data */

var data = {

username: "Michael",

password: "newpass",

gendor: "boy",

interest: ["B","C"],

option1: ["1","3"],

option2: "3"

}

<!-- HTML -->

<form id="form3" name="form3">

<label>Username</label>

<input type="text" name="username" id="username">

<br>

<label>Password</label>

<input type="text" name="password" id="label">

<br>

Gendor:

<input type="radio" name="gendor" value="boy" id="radiobutton">

<label>Boy</label>

<input type="radio" name="gendor" value="girl" id="radio">

<label>Girl</label>

<br>

Interest:

<input type="checkbox" name="interest" value="A" id="interest">

<label>A</label>

<input type="checkbox" name="interest" value="B" id="interest">

<label>B</label>

<input type="checkbox" name="interest" value="C" id="interest">

<label>C</label>

<br>

<label>Option</label>

<select name="option1" size="3" multiple="true">

<option value="1" selected>Option1</option>

<option value="2" selected>Option2</option>

<option value="3">Option3</option>

</select>

<select name="option2">

<option value="1">Option1</option>

<option value="2" selected=true>Option2</option>

<option value="3">Option3</option>

</select>

<label></label>

<input type="submit" name="submit" value="submit" id="Submit">

</form>

/* Binding */

Buffalo.Bind.bind("form3", data);

或Buffalo.Form.bindForm("form3", data);

　　绑定结果: 见图中form3
点击在新窗口中浏览此图片
　　
　　转换form为bean

　　一些用户恨透了在进行一次远程调用时从form中构造参数。Buffalo.Form.formToBean会使这一切变得简单。
Buffalo.Form.formToBean(form, buffaloObjectClass, ignoreButton)

上面的代码片断将转换form为buffaloObjectClass类型的bean。

　　参数说明:
　　１.form:form id或是form对象，这是必需的参数。
　　２.buffaloObjectClass:你要转换为的类，不是必备参数。如果没有提供，buffalo默认为是java.util.HashMap类。
　　３.ignoreButton:转换过程中是否忽略掉form中的button。不是必备参数，默认为true。

　　转换风格:
　　１.所有的值都是字符串或者字符串的列表。
　　２.单个字符串值将被转换为字符串，多个字符串值将被转换为字符串的列表。服务器端将使用java.util.List类来存放字符串的列表。

Tags - , , , , ]]> http://zhoujin.com/post/67/ <![CDATA[Wine 0.9.35]]> chirs <> Mon, 16 Apr 2007 02:40:49 +0000 http://zhoujin.com/post/67/ Wine 在昨天推出了一个新的版本 0.9.35，该版本包括一些新的改进，同时，也修正了之前版本中所存在的许多 bug。目前仅有此版本的源码包可用，适用于各发行版的二进制包还尚需时日。

Wine

Wine 0.9.35 的主要更改情况如下：

  • 损坏的 aRts 声音驱动程序已被移除；
  • 修正了 Quartz DLL 声音支持的问题；
  • 改善了文件的 I/O 性能；
  • 针对 Direct3D 的修订。

Download Wine 0.9.35


Tags - ]]> http://zhoujin.com/post/65/ <![CDATA[不到50MB的全功能发行版──Damn Small Linux ]]> chirs <> Fri, 30 Mar 2007 07:09:42 +0000 http://zhoujin.com/post/65/ 点击在新窗口中浏览此图片 Linux的众多发行版真是各具特色啊！
上次介绍过一个能构成Linux集群的LiveCD版──ParallelKnoppix，详见：http://www.zhoujin.com/read.php/66.htm，今天我再来介绍一个不到50MB的功能丰富的发行版──Damn Small Linux。
来看看其主要介绍：
引用
Damn Small Linux是一套基于业务卡（50M字节）可启动光盘的Linux发行。尽管它的个头如此之小，它努力成为一份可用并且易用的桌面。Damn Small Linux的桌面几乎是完整的一套，包括xmms（支持mp3和mpeg）、FTP客户端、基于links的web浏览器、电子制表软件、电子邮件程序、英语拼写检查、字处理器、三个编辑器（nedit、nvi及类似emacs的zile）、xpdf阅读器、worker文件管理器、naim（支持 AIM、ICQ和IRC）、VNCviewer、SSH/SCP服务器和客户端、DHCP客户端、PPP及PPPoE、web服务器、计算器、 Fluxbox窗口管理器、系统监视软件、USB支持，并且它很快就将拥有PCMCIA支持。如果你喜欢Damn Small Linux，你可以安装到你的硬盘上。由于所有的软件都是小巧型的，所以它对老旧的硬件会是一个很好的选择。

根据DistroWatch上的消息，今天这个Linux刚刚发布了3.3Rc3版，我想既然这么小，我也下载来体验一下。
详情请见：http://distrowatch.com/?newsid=04121，才49.6MB的ISO……
Tags - ]]> http://zhoujin.com/post/64/ <![CDATA[Ubuntu Feisty Beta版发布了]]> chirs <> Fri, 30 Mar 2007 06:55:27 +0000 http://zhoujin.com/post/64/ 点击在新窗口中浏览此图片 在结束了五个Herd测试版后，Ubuntu Feisty将迎来Beta版了。不过出现了一点点意外，Ubuntu Feisty Beta版的发布要延迟一天。（哈哈~才一天，只要最终版不跳票就行了）

最新最流行的Linux操作系统──Ubuntu Feisty的Beta版，因为内核更新的关系延迟发布一天。
今天早上Tollef Fog Heen给Ubuntu开发者列表的邮件中写到：“因为内核引起的启动问题，Ubunt Feisty的Beta版将在周五发布。”
“一个新的内核将上传并编译，同样的还有新的debian安装器。当我在写这封邮件时时，新的ISO镜像正在制作和发布。”
"DVDs will be re-rolled tomorrow morning since they need new livefs-es built and due to the order we build the ISOs in, they aren't yet."question不会翻译……
Heen说ISO镜像将在周六完成最终测试，并且在周五会发布Beta版。

原文：http://www.tectonic.co.za/view.php?src=rss&id=1418
Beta版将发布了，离正式版越来越近了~真期待！
Tags - , ]]> http://zhoujin.com/post/63/ <![CDATA[对web.xml 的几点配置心得]]> chirs <> Wed, 21 Mar 2007 09:19:35 +0000 http://zhoujin.com/post/63/ 参考
http://gceclub.sun.com.cn/staticcontent/html/sunone/app7/app7-dg-webapp/ch6/ch6-4.html
1.指定了自己的javaEncoding
<servlet>
        <servlet-name>jsp</servlet-name>
        <servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
        <init-param>
            <param-name>fork</param-name>
            <param-value>false</param-value>
        </init-param>
                <init-param>
            <param-name>javaEncoding</param-name>
            <param-value>GB18030</param-value>
        </init-param>
        <init-param>
            <param-name>xpoweredBy</param-name>
            <param-value>true</param-value>
        </init-param>
        <load-on-startup>3</load-on-startup>
    </servlet>

2.添加rar,iso等的mime-type映射
避免在浏览器里直接打开。
<mime-mapping>
<extension>mht</extension>
<mime-type>text/x-mht</mime-type>
</mime-mapping>
<mime-mapping>
        <extension>rar</extension>
        <mime-type>application/octet-stream</mime-type>
    </mime-mapping>
    <mime-mapping>
        <extension>iso</extension>
        <mime-type>application/octet-stream</mime-type>
    </mime-mapping>
    <mime-mapping>
        <extension>ape</extension>
        <mime-type>application/octet-stream</mime-type>
    </mime-mapping>
    <mime-mapping>
        <extension>rmvb</extension>
        <mime-type>application/octet-stream</mime-type>
    </mime-mapping>
    <mime-mapping>
        <extension>ico</extension>
        <mime-type>image/x-icon</mime-type>
    </mime-mapping>

   <mime-mapping>
   <extension>doc</extension>  
<mime-type>application/msword</mime-type>  
</mime-mapping>  
<mime-mapping>  
   <extension>xls</extension>  
   <mime-type>application/vnd.ms-excel</mime-type>  
</mime-mapping>  
<mime-mapping>  
   <extension>ppt</extension>  
   <mime-type>application/vnd.ms-powerpoint</mime-type>  
</mime-mapping>

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

Tags - , , , , , , , , ]]> http://zhoujin.com/post/62/ <![CDATA[竟然这么想你~~~]]> chirs <> Sat, 17 Feb 2007 08:05:46 +0000 http://zhoujin.com/post/62/ 竟然这么想你,
忘了你不在这里,
透过信息开始思念你,
不知不觉我又在想你.
扰乱我的收听,
都是你的声音,
害我的耳朵不安静~!
竟然这么想你,
竟然这么想你,
相信我别怀疑,
任时光点滴流逝,
可不知不觉我竟又在想你~!
扰乱我的视线,
都是你的身影,
害我的凝视不安静,
扰乱我的心情,
害我的脚步不安静,
扰乱我的思绪,
都是你的声音,
害我的沉默不安静~!
纵是月色迷离,
思念风儿为我传递,
我却听见了,
你轻声的叹息,
谁能遮得住思念在呼吸???
Tags - ]]> http://zhoujin.com/post/60/ <![CDATA[Web下的整体测试]]> chirs <> Tue, 13 Feb 2007 03:47:14 +0000 http://zhoujin.com/post/60/      B/S下的功能测试比较简单，关键是如何做好性能测试。目前大多数的测试人员认为只要跑一些测试工具证明我的产品是可以达到性能的就ok了，为了证明而去测试是没有任何价值的，关键是要发现产品性能上的缺陷，定位问题，解决问题，这才是测试要做的。

   随着Internet的日益普及，现在基于B/S结构的大型应用越来越多，可如何对这些应用进行测试成为日益迫切的问题。有许多测试人员来信问我B/S的测试如何做，由于工作较繁忙，对大家提出的问题也是头痛医头脚痛医脚，没有对WEB的测试过程做一个整体的概述。希望通过本篇能够让大家了解大型Web应用是如何来进行测试的。
   B/S下的功能测试比较简单，关键是如何做好性能测试。目前大多数的测试人员认为只要跑一些测试工具证明我的产品是可以达到性能的就ok了，为了证明而去测试是没有任何价值的，关键是要发现产品性能上的缺陷，定位问题，解决问题，这才是测试要做的。
   首先我们从两个方面分析如何进行WEB测试，从技术实现上来讲一般的B/S结构，无论是.NET还是J2EE,都是多层构架，有界面层，业务逻辑层，数据层。而从测试的流程上来说，首先是发现问题，分析问题，定位问题，再由开发人员解决问题。那么B/S的结构的测试如何来做？
   如何发现问题是我首先要介绍的，在做WEB测试之前你需要一些资料，比如产品功能说明书，性能需求说明书，不一定很完善，但一定要有，明确测试目标，这是基本的常识，可是我往往看到的是已经开始动手测了，但还不知自己的系统要达到的性能指标是什么。这里我简单讲一下测试的性能指标：
1、通用指标（指Web应用服务器、数据库服务器必需测试项）:
* ProcessorTime: 指服务器CPU占用率，一般 平均达到70%时，服务就接近饱和；
* Memory Available Mbyte : 可用内存数，如果测试时发现内存有变化情况也要注意，如果是内存泄露则比较严重；
* Physicsdisk Time : 物理磁盘读写时间情况；
2、Web服务器指标：
* Avg Rps: 平均每秒钟响应次数＝总请求时间 / 秒数；
* Avg time to last byte per terstion （mstes）:平均每秒业务角本的迭代次数 ,有人会把这两者混淆；
* Successful Rounds：成功的请求；
* Failed Rounds ：失败的请求；
* Successful Hits ：成功的点击次数；
* Failed Hits ：失败的点击次数；
* Hits Per Second ：每秒点击次数；
* Successful Hits Per Second ：每秒成功的点击次数；
* Failed Hits Per Second ：每秒失败的点击次数；
* Attempted Connections ：尝试链接数；
3、数据库服务器指标：
* User 0 Connections ：用户连接数，也就是数据库的连接数量；  
* Number of deadlocks：数据库死锁；  
* Butter Cache hit ：数据库Cache的命中情况；  
   上面的指标只是一些通用的指标,起到抛砖引玉的作用，对于不同的应用你还必需作相应的调整，比如程序使用的是.NET技术的，则必需加入一些针对性的测试指标。对于这些指标的详细了解，你可以参考Windows 下面的 SystemMonitor的帮助与LoadRunner、ACT的帮助。对于发现问题，指标的设置非常重要，它会帮你定性的发现一些错误。对于定性的压力测试我就不做过多的分析，工具很多，流行的主要有LoadRunner,ACT,WAS,WebLoad,各个工具有它的使用范围，其中我各个认为LoadRunner 最全面，它提供了多种协议的支持，对复杂的压力测试都可以胜任，WAS与ACT则对微软的技术支持的比较好，其中WAS支持分布式机群测试,ACT则是
与.NET集成比较好，支持ViewState （.NET 下控件缓存的支持） 的测试，当时我用时，其它测试工具还不支持，现在应该支持了吧，呵呵。在这一阶段测试你要不断的跟据系数的测试目标进行变化，一开始由于系统过于庞大，所以我们要分成若干个子系统，各个子系统的性能目标必需明确，主要是并发指标定一个阈值，同时设定一些与系统相关的测试参数，应用服务器，数据库服务器都要有，对达不到阈值的与一些通用参数有问题的子系统进行深入分析。比如它的并发达不到你的要求，证明子系统性能有问题，或是数据库用户连接过高，程序没有释放用户连接等等。这个我们要对子系统进行详细测试，由于B/S 结构下,图片的请求对性能的影响较大，所以我们对子系统测试时要分两个部分进行，一、非程序部分，即图片等等；二、应用程序本身。通过事务或函数的分离，可以把这两块实现单独的测试，具体做法参考各个工具的手册，我这里就不做说明。对子系统的测试参数的设置要求则更高，它有助你后面精确的定位问题，比如对异常，死锁，网络流量等等前面没有注意到的情况的增加，同时你要注意增加测试参数的收集对系统的性能影响比较大，所以一般不要超过10个，刚刚介绍的整体的性能
测试指标也不要增加很多，这样影响会小一点。最后在这一阶段要说明的是数据库的数据量会很大程度的影响性能，所以要根据前面的性能需求说明书向数据库中模拟相应的数据量，来进行测试，这样才有更高的可信度。
   上面所说的是对问题的发现，下面就是分析问题原因，这一步的要求比较高，一般由测试人员与程序员配合完成，当然如果你有相当的开发经验，再做这方面的测试，就更为难得。下面我们说说如何精确定位问题，出现问题的可能性可能有很多种，大致分以下几种，一、性能达不到目标；二、性能达到目标，但有一些其它的问题，比如异常，死锁，缓存命中过低，网络流量较大；三、服务器稳定性的问题，比如内存泄漏……。要发现这些问题起马的要求要有一款使用的比较称心的性能分析与优化工具，比如微软的.NET下就有自己开发的工具，对Borland的Java开发工具中也有类似的工具，但我个人认为更好的工具是Rose下的Purify与Quantify,主要是他对.net 与java ,C++都有支持，而且分析效果特别专业，我们先了解一下
Rational Purify, Rational Purify 能自动找出Visual C/C++ 和Java 代码中与内存有关的
错误，确保整个应用程序的质量和可靠性。在查找典型的Visual C/C++ 程序中的传统内存访问错误，以及Java，C# 代码中与垃圾内存收集相关的错误方面；Rational Quantity 则是一款针对函数级的性能分析利器，使用它你可以从图形化的界面中得到函数调用的时间，百分比与次数，以及子函数所占时间，使你可以更快的定位性能瓶颈。
   我们先说性能优化与异常的处理，性能优化有一个原则，即用时间比例最大的进行优化，效果才最明显，比如有个函数它的执行时间为30秒，如果你优化了一百倍则执行时间为0.3秒,提升了29.7秒，而如果它的执行时间为0.3秒，优化后为0.003秒，实际提升了0.297秒，提升的效果并不明显，而且写过程序的人都知道，后者性能优化的代价更大。在性能优化的过程中，一般是先数据库，后程序，因为数据库的优化不需要修改程序，修改的风险很小。但如何才能确定是数据库的问题，这就需要技巧，在使用Quantity时，你一路分析下去，大多数最终会发现，是数据库查询函数占用时间比较大，比如什么，SqlCmd.ExecuteNoQuery等等数据库执行函数,这时你就需要分析数据库，呵呵。数据库的分析原则是先索引，后存储过程，最后表结构视图的优化，索引的优化是最简单也是通常最有效的方法，如果合理的使用会带来意想不到不到的效果。在这里我要给大家简单的介绍一下我的最爱，SQLProfile,SQL查询分析器，Precise,SQLProfile是一个SQL语句跟踪器，可以跟踪程序流程使用的SQL语句与存储过程，结合查询分析器对SQL的分析，可以对索引的优化做出很好的判断，但索引也不是万能的，在增删改较多的表，索引过多会引起这些操作的性能下降，所以判断还是需要一定的经验。同时针对用户使用频度最高的SQL进行优化也是最行之有效的，这时我则需要Precise，它可以观测某一个较长时间内的SQL语句的执行情况。数据库优化的潜能挖光后，如果还是达不到性能要求或是还有问题，则要从程序来进行优化，这是程序员做的事，测试人员要做的，就是告诉他们，哪个函数执行过多引起了性能下降，比如异常过多，某个循环过多，或是DCOM调用过多等等，但说服程序员也是一件不容易的事，你要在这一阶段做的出色一定要有几年的编程经验，并且要让程序员感到听你的性能会有提升，这是一件很不容易的事情哦。
   内存的分析，一般是一个长期分析的过程，要做好不容易，首先要有长期奋战的准备，其次内存泄漏的分析最好是放在单元测试之中同步进行，而不是要等到最后再去发现问题，当然出了问题也只好面对，一般这类问题都是在服务器运行了很久才暴露出来，一旦发现问题后，则需要定位问题，分析的原则采用子系统相互独立运行，找到最小问题的系统集,或是借助内存分析工具观察内存对象情况，初步定位问题，再用Purify进行运行时分析，通常C++ 内存问题比较多，Java与.NET比较少，一般由GC不合理引起。C++的内存错误就比较多了，主要常见的有:  
1、 Array Bounds Read (ABR) ：数组越界读  
2、 Array Bounds Write (ABW)：数组越界写  
3、 Beyond stack Read (BSR)：堆栈越界读  
4、 Free Memory Read(FMR)：空闲内存读  
5、 Invalid pointer Read(IPR)：非法指针阅读  
6、 Null Pointer Read(NPR)： 空指针阅读  
7、 Uninitialized Memory Read(UMR)：未初始化内存读写  
8、 Memory Leak：内存泄漏  
注：如果需要更多的信息，可以参见Purify的帮助信息。  
   顺便提一句，为什么我要说单元测试时做这个比较好，由于单元测试针对的是单一功能，这时结合单元测试案例做内存分析会更快的定位问题，同时由于问题较早的发现，则后期的风险则会减少，当然如果结合代码覆盖工具PureCoverage 来做就更完美了。
   注：本篇只是对B/S应用的测试过程作一个整体的描述，对某一个阶段使用的工具只是作
大概的介绍,你也可使用你比较熟悉的工具达到相同的目标。
Tags - , ]]> http://zhoujin.com/post/59/ <![CDATA[驰名世界的奢侈品牌史话：巴宝莉(Burberry) ]]> chirs <> Mon, 12 Feb 2007 11:46:32 +0000 http://zhoujin.com/post/59/
　　曾经给布料商当学徒的托马斯·巴伯利精明过人，他在1880年利用新的织造方法，发明了一种防水、透气、耐磨的斜纹布，并在1888年获得了专利。1891年，巴伯利在伦敦Haymarket开了在英国首都的第一家店，现在那里仍是巴宝莉公司的总部所在地。

　　19世纪末，巴宝莉为军官设计了一种叫“Tielocken”的风衣，它也是今天著名的巴宝莉风衣的雏形。1901年，巴宝莉正式受英国军方委托，为英国军官设计新的制服。此时，巴宝莉著名的“马背骑士”标识面世，巴宝莉公司将它注册为商标。20世纪最初的10年里，巴宝莉开始扩张自己的市场，并跨出英国国门，在巴黎和纽约建立起自己的专卖店。

　　1911年发生了一件轰动全球的事情，“巴宝莉”这个品牌也因此而扬名。这一年，挪威探险家罗阿尔·阿蒙森上校率领一只5人的小分队，成功地成为了世界上最早抵达南极点的人，而他装备的就是巴宝莉品牌的户外用品和服饰。他在南极点留下了一个巴宝莉的斜纹布帐篷，以向后来者证明他完成了这次探险。在阿蒙森到达南极后，爱尔兰人欧内斯特·沙克尔顿决定首先横穿南极大陆，而他的探险队使用的也是由巴宝莉生产的户外产品。

　　第一次世界大战期间，巴宝莉继续为英国军队设计军服。1924年，巴宝莉注册了它的另一个著名标志：格子图案。这种由红、白、黑、浅棕四色组成的格子图案，当时被巴宝莉用在了风衣内衬上，后来几乎成为了巴宝莉的同义词。1930年，巴宝莉还参与了飞行员服饰的设计。

　　凭着传统、精谨的设计风格和产品制作，1955年，巴宝莉获得了由伊丽莎白女王授予的“皇家御用保证(Royal Warrant)”徽章。后来在1989年，巴宝莉又获得了威尔士亲王授予的“皇家御用保证”徽章。1967年，巴宝莉开始把它著名的格子图案用在了雨伞、箱包和围巾上，愈加彰显了巴宝莉产品的特征。

　　1970年，巴宝莉在纽约东57街上的旗舰店开张。1980年，巴宝莉在美国不断扩大零售业务，除纽约外，旧金山、芝加哥、波士顿、费城、华盛顿等地都可以见到它的连锁店。1997年，罗斯·玛丽·布拉沃担任巴宝莉公司的首席执行官，一支新的管理团队给巴宝莉带来了新的面貌。新的精品设计、新的产品序列以及与众不同的广告宣传，使巴宝莉这个老品牌获得新生。

　　1999年，布拉沃请来了英国最著名的时装模特凯特·莫斯为巴宝莉拍摄了一组广告片和海报。在一幅直到今天仍被奉为经典的海报上，凯特·莫斯身着格子婚纱，与身穿格子燕尾服的新郎举行了一场“英伦格子婚礼”，婚礼上的所有嘉宾都穿着带有巴宝莉格子的服饰，婚礼上的所有用具也都用巴宝莉格子作为装饰。这些海报在各地好评如潮，它不但使巴宝莉再度成为了热门的时尚品牌，而且让这个品牌迅速受到各年龄段消费者的青睐。

　　新世纪来临之际，巴宝莉已经以其不朽的风尚，成为了一种生活品质的象征。2000年和2001年，巴宝莉获得了英国时装理事会古典和现代两个设计系列的大奖。进入21世纪，巴宝莉加快了其在全球的扩张步伐。2000年9月，它的全球旗舰店在伦敦新邦德街开张。2001年10月，巴宝莉把在洛杉矶的旗舰店开到了好莱坞明星云集的贝弗利山。此后，巴宝莉在德国、西班牙、意大利、俄罗斯、日本的一些重要城市建起了更多独具风格的专卖店。

　　今天，巴宝莉经典的格子图案、独特的布料功能和大方优雅的剪裁，已经成为了英伦气派的代名词。在一些字典里，“Burberry”的意思即是：风衣。
Tags - , ]]> http://zhoujin.com/post/57/ <![CDATA[JSF 这一年]]> chirs <> Tue, 06 Feb 2007 01:02:45 +0000 http://zhoujin.com/post/57/     
       可以说各大厂商在互相妥协让步的基础之上，把 JSF 实用化的实现版本的重任交到了 Apache Myfaces 项目上，而 Oracle 也将其 ADF Faces 的实现捐给了 Apache，而现在我们可以见到的 JSF 实现也主要就是 Myfaces 了，当然 Sun 自己也有一套实现，当然这只是一种不够健壮，并且功能有限的实现版本，一般不会拿来做正式的项目的。刚过完年 Myfaces 1.1.2 和 Tomahawk 1.1.2 正式发布，这是过去 Myfaces 1.1.1 的一个 bug 修复版本，离上一个版本已经有半年左右的时间了，而项目组的同事们也在与 Myfaces 1.1.1 的 bug 斗争了半年才用到这个新的版本。随后的 Myfaces Core 1.1.3 / 1.1.4 则在几乎一个月内发布，而 1.1.5 和 Tomahawk 1.1.4 则至今没有动静，虽然由 Myfaces 每次发布带给我们的 new feature 已经不是那么的多了，但是还是期盼新的版本能够给我们带来新的惊喜
。
     五月份的时候 JavaEE 5 最终标准发布了，JSF 1.2 终于被正式提上了日程，这是一个对过去标准的一个修复版本，修正了上一个标准中的诸多问题，比如 JSTL 兼容性问题，还有一些细节性的改动，都是过去在 JSF 1.1 标准中非常折磨人的问题，但新的 1.2 标准依赖于 JDK 1.5，依赖于一系列新的 JavaEE 5 的 API，比如 Servlet 2.5, JSTL 1.2 而这些新的 API 也是在紧锣密鼓的开发中，所以 Myfaces 1.2 的开发进程也一直很慢，因为其中出现的问题不光是 Myfaces 自己的问题，或许还有 Tomcat 6 的问题，或是其他的问题。而另一方面 Sun 也发布了一个 JSF 1.2 的实现版本，是由 JSF 1.2 的标准的主笔领导开发的，按照我对于 Sun JSF 上个版本的表现，我对于这个新的实现也不抱有太多的希望，或许它更多的只是一种象征了，象征着 JSF 1.2 的正式推出。
     开源领域的 JSF 相关的项目发展缓慢。Myfaces 在一年内没有给我们带来太多的惊喜。曾经做为黑马出现的 JSF 扩展框架 Shale 至今还没有给大家带来一个满意的答复，一直以 develop 版本发布出来给大家尝鲜用，虽然慢慢的在前进，但是却很难带给大家什么惊喜，或许会被人逐渐的淡忘。而去年年底由 Oracle 捐给 Apache 的 ADF Faces 也是至今没有太大的动静，同样作为兄弟项目的 Struts 2 从提出到现在也有一年了，还没有能提供一个正式的版本给我们用，作为 Apache 的项目，这样的发布速度，确实很让人不能满意，而作为另一个大型的开源组织 Eclipse，则在一个个 Milestone 下有条不紊的向前推进，不断蚕食着别人所占据的地盘。
     作为 JSF 整体应用平台一个重要的部分，第三方组件库的发展有不小的突破，但是真正的应用度似乎不是很高，这一年内出现了很多优秀的商业，开源的组件库，除去上面我们提到的 Myfaces Tomahawk, Oracle ADF 之外，还出现了 ICEFaces， BackBase，WebGalileo Faces，另外在 .Net 领域的组件提供商 Infragistics 也通过收购发布了 NetAdvantage for JSF 2006 这样的组件库。另外一直在 JSF IDE 上有所作为的 Exadel 公司也在 JSF 组件上插上一手，一方面发布了其开源的 JSF 框架 Ajax4JSF 另一方面在其基础上提供了一个商业的 JSF 组件库 VCP，这样的方式确实有一套，可以同时抓住两方面的市场。另一方面国内也出现了像金碟这样基于自己 Apusic Application Server 的开源 JSF 组件库，是一件值得我们国人骄傲的事情，不过由于其只能够运行于 Apusic 上，使其应用面受到了不小的限制。
     让我们再来看看这一年 JSF 相关 IDE 在今年的作为了，在 06 年春节期间，一些支持 JSF 的 IDE 像赶集一样不断的推出来，先后有 MyEclipse 4.1 GA，Sun Java Studio Creator 2， Oracle JDeveloper， BEA Workshop Studio 3.0，在这一段时间推出。MyEclipse 和 BEA Workshop 是 Eclipse 的插件，而 JDeveloper 和 Creator 是基于 Swing 的，不过随着时间的推移，大家真正在用的 JSF 开发工具也主要就是 MyEclipse 和 Workshop，不过 MyEclipse 在 JSF 上想和 Workshop 拼，还需要一些时日了，另外在九月份正式发布的 IntelliJ IDEA 6.0 也开始支持 JSF 了，当然是用其独特的方式去支持，虽然不提供图形化的所见即所得的开发方式，但由于其 IDE 内部各个部分间完美的组合，使得其在写代码的感觉上要远远超过的其他竞争者，这也正是独立 IDE 和插件 IDE 一个重要的功能区别。
     纵观 06 年的 JSF 的发展历程，我还是对 07 年的 JSF 的发展很期待，希望 Myfaces 基于 JSF 1.2 的实现能够尽快的推出，也能够有更多更好的开源组件库的出现。
Tags - , , ]]> http://zhoujin.com/post/56/ <![CDATA[台湾报纸关于［中国工农红军长征］的阐述 ]]> chirs <> Wed, 17 Jan 2007 04:46:38 +0000 http://zhoujin.com/post/56/
［长征］：是指上个世纪30年代，中共领导的、由一群目七拼八凑的、没有工作的工人和没有土地的农民所组成的、反叛国民政府的武装叛军——［红军］在强大的国军五次精心组织的围剿下，从盘据的江西山区有组织的狼狈逃窜过程。[ 转自铁血社区 http://bbs.tiexue.net/ ]

内文：

从1934 年10月开始，英勇强大的国军对溃逃的［红军］进行了致命的追击，通过［湘江歼灭战］、［四堵赤水逼迫战］、［乌江拦截战］、［铁索桥以少胜多之战］、［追敌入草地之策略战］、［赶匪上雪山之巧计战］、［六盘山阻击战］等大小战役，范围包括江西、湖南、贵州、四川等众多省份，国军转战征程将近两万五千里，历时两年，直至1936年10月将共党［红军］从江西赶到陕西境地。［红军］死伤惨重，大部被歼，一路病死、饿死、被捕者人众。最终，号称三十万人之众［红军］被消灭至仅剩数万老弱残兵。

续言：

国军并未因［红军］仅余不堪一击的数万残部而作罢，继续对其进行剿灭。数百万精良装备的国军对用小米加步枪武装的剩余［红军］（后称之为：“共军”）组织了大大小小无数次精彩围歼战役。经过了近13年（包括[八年抗战]的被迫合作期）的成功奋斗，国军围剿共军从大陆一路追杀至台湾，最终将共军困在大陆将近六十年之久。

终言：

围剿尚未成功，国军还需努力。我们一定要为实现将共军赶入台湾岛的最终目标而奋斗！
Tags - , , ]]> http://zhoujin.com/post/55/ <![CDATA[XSL模板的学习笔记]]> chirs <> Wed, 17 Jan 2007 03:00:03 +0000 http://zhoujin.com/post/55/
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns="http://www.w3.org/TR/xhtml1/strict">

xsl格式后，用下面解决页面title在FF下被打印出来。
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="eng">

xsl输入W3C文件头
<xsl:output method="html" encoding="gb2312" doctype-public="-//W3C//DTD XHTML 1.0 Transitional//EN"
doctype-system="http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"/>


让xsl显示HTML  
disable-output-escaping="yes"
  如： <xsl:value-of select="Root" disable-output-escaping="yes"/>

判断是否为空值用
normalize-space


判断节点是否存在
　<xsl:if test="not(节点)">

在xsl中title属性如何实现换行？
　用
：&#13;&#10;

xsl取xml中的序列号
　　类似于db的自动编号　
position()

XSL运算符：

　　除 　　　　　　　　155 div 100
　　求余　　　　　　　　155 mod 100
　　求和　　　　　　　　sum()　　　　　　　　　<xsl:value-of select="sum(//price)"/>
　　统计　　　　　　　　count()　　　　　　　　<xsl:value-of select="count(PERSON[name=tom])"/>

　　字符函数
　　　....长度　　　　　　string-length(str)
　　　....查找　　　　　　substring
　　　....查找　　　　　　substring-after

　　转换为数值　　　　　number()　　　　　　　　<xsl:value-of select="number(book/price)"/> 如果非数值，返回空。


XSL使用自定义函数

声明：
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns="http://www.w3.org/TR/xhtml1/strict" xmlns:msxsl="urn:schemas-microsoft-com:xslt" xmlns:Missde="MissdeVBS" xmlns:MissdeJS="MissdeJS">

函数：

<msxsl:script language="VBScript" implements-prefix="Missde">
<![CDATA[
　　　这里写VBS
]]>
</msxsl:script>
<msxsl:script language="javaScript" implements-prefix="MissdeJS">
<![CDATA[
　　　这里写JS
]]>


调用：
<xsl:value-of select="Missde:函数名()"/>
<xsl:value-of select="MissdeJS:函数名()"/>


XSL使用自定义函数时的特殊情况
1.参数即可以是元素值、又可以是字符串
　解决办法：使用自定义函数函数。
　因为刚学xsl,xml，对相关属性不甚明了，所以所用方法应该有待完善。
　a)用VBS判断：
　　　　　function getnode(node)
　　　　　 dim str
　　　　　　if IsObject(node) then
　　　　　 　if(Node.Length>0)then
　　　　　 　　str=node.item(0).TEXT
　　　　　　else
　　　　　　 　str=""
　　　　　　 　end if
　　　　　　else
　　　　　　　str=node
　　　　　　end if
　　　　　　getnode=str
　　　　　End function
　b)用JS判断

　　　　function node(str){
　　　　　return str[0]?str[0].text:str;
　　　　}


2.使用自定义函数，简化XSL代码
　这里说的是特殊情况。比如说，需要在xsl引用一个动态地址，如js文件、img、url等
　以引用script为例：
　function script(name,a,b,c,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s){
　　name=name.toLowerCase=="js"?"javascript":"vbscript";
　　var url="";
　　var str=new Array(a,b,c,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s);
　　for(var i=0;i<str.length;i++){
　　　　if(str[i]!=undefined){
　　　　　　url+=node(str[i]);
　　　　}
　　}
　　return "<script language='"+name+"' type='text/"+name+"' src='"+url+"'></script>";
　｝


XSL排序
　　<xsl:for-each select="student">
　　　　<xsl:sort select="id" order='ascending'/>　　　　以id顺序排列
　　　　<xsl:sort select="name" order='descending'/>　　以name倒序排列
　　</xsl:for-each>


xsl条件查询
　　进行大小于比较的时候，先进行编码。如>写成<

xsl模板合并
　　方法一（二个）
　　　　用它引用
　　　　用它打印
　　方法二（多个）
　　　　主.xsl　调用

　　　　<xsl:import href="head.xsl"/>
　　　　<xsl:import href="foot.xsl"/>
　　　　<xsl:template match="html">
　　　　<xsl:call-template name="head"/>
　　　　　　本页主内容
　　　　<xsl:import href="foot.xsl"/>
　　　　</xsl:template>

　　　　子.xsl
　　　　<xsl:template name="head">
　　　　aaa
　　　　</xsl:template>


xsl模板合并时，主模板控制子模板head中的title

　　（暂用下面办法）
　　a).建全局变量title
　　b).head.xsl 引用自定义函数 showtitle()
　　c). main.xsl 引入head.xsl之前为全局变量title赋值。

　　　JS：

　　var title="";
　　function gettitle(a,b,c,e,f,g,h){
　　　　var str=new Array(a,b,c,e,f,g,h)
　　　　for(var i=0;i<str.length;i++){
　　　　　　if(str[i]!=undefined){
　　　　　　　　title+=node(str[i])+ " - ";
　　　　　　}
　　　　}
　　　　return "";
　　}
　　function showtitle(){
　　　　return title;
　　}

Tags - ]]> http://zhoujin.com/post/54/ <![CDATA[任何一个生命来到这个世界上都有它生存的权利]]> chirs <> Sun, 14 Jan 2007 05:56:24 +0000 http://zhoujin.com/post/54/ “过去的事就改了个名就不存在了吗？不光是改了名，还不能见以前的人，不能聊以前的事，甚至还得当以前根本就没存在过，对吗？让我想想，真的，丁伯，得让我想想。” 王谦说他去见姚兰和爱不爱没有关系，该承担的总躲不了。  
“我必须这么做，我躲不了，我也不想躲了，我不愿意就这样跟你待在一起，我受不了。”  
“我在外面躲了两年，我不能因为珍惜自己的命，就不管别人的命，这是应该还的。”  

“任何一个生命来到这个世界上都有它生存的权利  
都应该享受生命带给他的自由  
主宰自己肉体和精神的快乐和痛苦  
这是任何人都不能剥夺的  
一个生命无论多么渺小都是平等的  
我结束了一个人的生命    
我痛恨我自己”    

就是他的这份敢担当的勇气让我感动。这种勇气现在有多少人有。爱情上，爱过了受了打击就选择逃避、自暴自弃，不愿见自己爱过的人，尤其是一些男孩，怎么就没有想办法让自己所爱的人更加幸福呢？平时遇到什么事就躲，不愿去解决，该自己承担的总没勇气去承担。  


“这一重负几乎重如一个世界，我却担起了。原以为能一直担着走到头，而我承担是根据我的心愿，而不是凭力量；是根据我的意志，而不是凭能力。可是刚刚要到中途，就不得不放下。十四年的绝望和十年的希望把我变成了主宰命运的人。现在我又得听天由命了。人世间无所谓幸福与不幸，只有一种境况与另一种境况相比较，仅此而已。只有经受了极度不幸的人才能感受到极度幸福；渴求过死亡的人，才能领悟到活在世上有多美好。你们生活吧，幸福吧，我心爱的孩子们。永远也不要忘记，在上帝肯向人类揭示未来之日到来之前，这两个词就含括了人类的全部智慧——等待和希望。”  

这是《基督山伯爵》结束的一段话。可是这又何尝不是王谦的感悟呢！从被姚军追杀，到白石镇被陷害，到拯救小宝，哪一次在逆境中他放弃过，正是他心里的正义和爱使他从没放弃过。被姚军追杀，姚母所逼，最后不得不离开姚兰。是因为他太爱姚兰了，所以自卑，不想给姚兰带来任何不幸，所以选择离开。白石镇奋不顾身救刘新朋，不管自己情况怎么糟糕，后果会怎样，在他的心里只有正义和救人这两个词。现实生活中有这么仗义的吗？在大部分人眼里只有钱和命！救小宝，就是再艰难也一定要回去，他只知道他要救人。这是一种怎样的爱啊！所有的这些承担，有谁能说他不是根据自己的心愿和意志呢！所以我喜欢他，真的喜欢他！  

不管发生什么事，自己兄弟最重要！身负重伤去警告伤害自己兄弟的人。心地是如此善良。  
在白石镇杨大婶给了他几个包子，就一定要报答别人。后来为他治伤，就拼死保护刘新朋，刘新亮。他知道哪怕受别人一点恩惠，也要报答。滴水之恩当涌泉相报！  
看书时他能安安静静的坐在那儿一整天，把《基督山伯爵》里的那段话牢记在心里。  
他就是这么简单，安静、诚恳。现代人的脑袋太复杂了！  

“生命和金钱不是对等的，生命是无价的，钱是能数得出来的。我做了件蠢事，把无价的东西变成有价的，也就是把自己贬低了。这世上还是好人多。”    
可是现实中有多少人在拿可贵的生命去换取那数得出的钱呢！有谁是根据自己的心愿和意志去做自己喜欢的事呢！  

“人的生命是那么的脆弱，逝去了就再也没有救赎的可能。我终于明白，生命的意义不只在于结果，还在于过程。我必须要去面对曾经所做的一切，这也是我生命的一种意义，该我承担的我就不该逃避了。”  
他知道生命的珍贵，可是我们又有多少人在践踏自己的生命！  

能和这样的人在一起就没有什么是不可能的，是一种精神上的爱，聚少离多又怎么样，就是辛苦也是幸福的。因为他不是柔柔软软的爱，不是为爱情而爱。他们有支撑下去的力量！就是心愿和意志！王谦值得姚兰为他付出生命！  
我真的自从看了这片子使我想起了很多很多,以前的,将来的,好的,坏的 ,我第1次感受到了人的生命是多么可贵同时又是多么地脆弱,生活中遇到点儿事儿就逃,活着就是得过且过,上网啊,找女朋友啊,都是干这些,这样的生命有意义吗?是,是你不想学习,耐不住寂寞,所以你就选择逃避,一次又一次,难道你就这样过吗?人生活是要有信念的,是要有追求的,解决问题的最好方法就是直接坦然面对!!再一个我觉得吧,人是感情动物,活得应该尽情尽义,真实一点,干嘛那么虚啊,只有一个人有了渴望活着的信念,才能知道生命是多么可贵!我想明白了,自己就是这么回事儿!  
Tags - , , ]]> http://zhoujin.com/post/58/ <![CDATA[BEA Workshop Studio 3.3 released]]> chirs <> Sat, 06 Jan 2007 01:03:20 +0000 http://zhoujin.com/post/58/
In addition, Workshop Studio 3.3 includes the following minor feature upgrades:
Upgraded from Web Tools Platform (WTP) 1.5.1 to 1.5.2 -- this is a bug fix release
Upgraded from Kodo 4.0 to 4.1
Support for Spring 2.0
Support for Hibernate and Hibernate Entity Manager 3.2
Support for opening .tld and .tag files located in JAR files
Minor bug fixes and general improvements
Workshop 一直是我比较关注的 Plugin，可以说在 JSF 的支持上目前是无出其右，这次在原有的基础上又做出了一些改进，主要是支持 Spring 2.0, Hibernate 3.2, WTP 1.5.2，喜欢 JSF 的朋友可以尝试去申请一个试用版。
Tags - , , , , ]]> http://zhoujin.com/post/53/ <![CDATA[转：我和老婆已经为孩子到底姓什么争论很长时间了]]> chirs <> Tue, 26 Dec 2006 09:55:03 +0000 http://zhoujin.com/post/53/
我姓吕，老婆姓王，孩子本应该姓吕，无可厚非的，可老婆和她家人都认为吕是个小姓，随老婆姓王成为百姓之王才更吉利，能让孩子长命百岁。可我和我家人都很传统，孩子姓父姓那是天经地义，而且我爷爷就我这么一个孙子，哎。

眼看孩子就1岁多了，男孩，平时我只管他叫宝宝，乖乖，什么的，没个正式名字。老婆已经管他叫王宏力，叫了半年多了，因为她特崇拜那唱歌的，王力宏，所以起这名字，这也是她一定要孩子姓王的一个原因。

关键问题是，我家和她家已经为孩子到底姓什么弄得都红脸了，关系很紧张。大家说我该怎么办，
下面是回帖的啊 暴笑：点此查看
Tags - ]]> http://zhoujin.com/post/51/ <![CDATA[Java开源项目Hibernate包作用详解]]> chirs <> Tue, 19 Dec 2006 02:13:28 +0000 http://zhoujin.com/post/51/ 　　
　　下载Hibernate，例如2.0.3稳定版本，解压缩，可以看到一个hibernate2.jar和lib目录下有22个jar包：
　　
　　hibernate2.jar:
　　Hibernate的库，没有什么可说的，必须使用的jar包
　　
　　cglib-asm.jar:
　　CGLIB库，Hibernate用它来实现PO字节码的动态生成，非常核心的库，必须使用的jar包
　　
　　dom4j.jar:
　　dom4j是一个Java的XML  API，类似于jdom，用来读写XML文件的。dom4j是一个非常非常优秀的Java  XML  API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件，可以在SourceForge上找到它。在IBM  developerWorks上面可以找到一篇文章，对主流的Java  XML  API进行的性能、功能和易用性的评测，dom4j无论在那个方面都是非常出色的。我早在将近两年之前就开始使用dom4j，直到现在。如今你可以看到越来越多的Java软件都在使用dom4j来读写XML，特别值得一提的是连Sun的JAXM也在用dom4j。这是必须使用的jar包，Hibernate用它来读写配置文件。
　　
　　odmg.jar:
　　ODMG是一个ORM的规范，Hibernate实现了ODMG规范，这是一个核心的库，必须使用的jar包。
　　
　　commons-collections.jar：
　　Apache  Commons包中的一个，包含了一些Apache开发的集合类，功能比java.util.*强大。必须使用的jar包。
　　
　　commons-beanutils.jar：
　　Apache  Commons包中的一个，包含了一些Bean工具类类。必须使用的jar包。
　　
　　commons-lang.jar:
　　Apache  Commons包中的一个，包含了一些数据类型工具类，是java.lang.*的扩展。必须使用的jar包。
　　
　　commons-logging.jar:
　　Apache  Commons包中的一个，包含了日志功能，必须使用的jar包。这个包本身包含了一个Simple  Logger，但是功能很弱。在运行的时候它会先在CLASSPATH找log4j，如果有，就使用log4j，如果没有，就找JDK1.4带的java.util.logging，如果也找不到就用Simple  Logger。commons-logging.jar的出现是一个历史的的遗留的遗憾，当初Apache极力游说Sun把log4j加入JDK1.4，然而JDK1.4项目小组已经接近发布JDK1.4产品的时间了，因此拒绝了Apache的要求，使用自己的java.util.logging，这个包的功能比log4j差的很远，性能也一般。
　　
　　后来Apache就开发出来了commons-logging.jar用来兼容两个logger。因此用commons-logging.jar写的log程序，底层的Logger是可以切换的，你可以选择log4j，java.util.logging或者它自带的Simple  Logger。不过我仍然强烈建议使用log4j，因为log4j性能很高，log输出信息时间几乎等于System.out，而处理一条log平均只需要5us。你可以在Hibernate的src目录下找到Hibernate已经为你准备好了的log4j的配置文件，你只需要到Apache  网站去下载log4j就可以了。commons-logging.jar也是必须的jar包。
　　
　　使用Hibernate必须的jar包就是以上的这几个，剩下的都是可选的。
　　
　　ant.jar:
　　Ant编译工具的jar包，用来编译Hibernate源代码的。如果你不准备修改和编译Hibernate源代码，那么就没有什么用，可选的jar包
　　
　　optional.jar：
　　Ant的一个辅助包。
　　
　　c3p0.jar：
　　C3PO是一个数据库连接池，Hibernate可以配置为使用C3PO连接池。如果你准备用这个连接池，就需要这个jar包。
　　
　　proxool.jar：
　　也是一个连接池，同上。
　　
　　commons-pool.jar,  commons-dbcp.jar:
　　DBCP数据库连接池，Apache的Jakarta组织开发的，Tomcat4的连接池也是DBCP。
　　
　　实际上Hibernate自己也实现了一个非常非常简单的数据库连接池，加上上面3个，你实际上可以在Hibernate上选择4种不同的数据库连接池，选择哪一个看个人的偏好，不过DBCP可能更通用一些。另外强调一点，如果在EJB中使用Hibernate，一定要用App  Server的连接池，不要用以上4种连接池，否则容器管理事务不起作用。
　　
　　connector.jar:
　　JCA  规范，如果你在App  Server上把Hibernate配置为Connector的话，就需要这个jar。不过实际上一般App  Server肯定会带上这个包，所以实际上是多余的包。
　　
　　jaas.jar:
　　JAAS是用来进行权限验证的，已经包含在JDK1.4里面了。所以实际上是多余的包。
　　
　　jcs.jar：
　　如果你准备在Hibernate中使用JCS的话，那么必须包括它，否则就不用。
　　
　　jdbc2_0-stdext.jar:
　　JDBC2.0的扩展包，一般来说数据库连接池会用上它。不过App  Server都会带上，所以也是多余的。
　　
　　jta.jar：
　　JTA规范，当Hibernate使用JTA的时候需要，不过App  Server都会带上，所以也是多余的。
　　
　　junit.jar:
　　Junit包，当你运行Hibernate自带的测试代码的时候需要，否则就不用。
　　
　　xalan.jar,  xerces.jar,  xml-apis.jar:
　　Xerces是XML解析器，Xalan是格式化器，xml-apis实际上是JAXP。一般App  Server都会带上，JDK1.4也包含了解析器，不过不是Xerces，是Crimson，效率比较差，不过Hibernate用XML只不过是读取配置文件，性能没什么紧要的，所以也是多余的。
Tags - , , , , ]]> http://zhoujin.com/post/50/ <![CDATA[勿忘12.13-]]> chirs <> Tue, 12 Dec 2006 16:00:00 +0000 http://zhoujin.com/post/50/
12.13，一个让人想起就要落泪的日子；

12.13，是这个城市最深的痛，是市民心中难平的疤痕；

12.13，我们更深地体会到落后之辱。

12.13，警报响起，我们不忘死难同胞的屈辱，但请不要停下行进的脚步；

12.13，最深的痛埋在心底，最努力的现在把握最美好的未来。

半个多世纪过去了，浩浩荡荡的长江水仍然向前流着，无止无息。然而，时光可以流逝，而历史却无法忘却，也不应该被忘却，作为历史的回顾，不能只有四大发明，开元盛世，丝路花雨，也应该有日军的残暴罪行，南京30万同胞的遇难.....
记住着惨灭人寰的灾难吧，记住这中华民族的奇耻大辱吧，它会让我们更加明确，今后的路该怎么走......

－－历史上的今天－－－
2002年12月13日 火车登陆海南岛
2001年12月13日 美国宣布退出《反导条约》
2001年12月13日 北京奥运会组委会成立
1996年12月13日 联合国秘书长候选人产生　科菲·安南出任
1996年12月13日 中国现代话剧奠基人曹禺逝世
1993年12月13日 福州一台资企业发生特大火灾　死伤68人
1992年12月13日 大邱庄发生非法拘禁、殴打职工致死案
1979年12月13日 美国试验成功三叉戟Ⅰ式导弹
1978年12月13日 邓小平的讲话成为党十一届三中全会的主题报告
1971年12月13日 美、法总统发表联合公报宣布美元贬值
1937年12月13日 南京大屠杀
1937年12月13日 肖山令中将殉国
1932年12月13日 许德珩等被当局秘密逮捕
1924年12月13日 《现代评论》创刊
1797年12月13日 德国诗人海涅诞辰

Tags - , , , ]]> http://zhoujin.com/post/49/ <![CDATA[Javascript 插入UBB标签到表单、文本域、函数]]> chirs <> Mon, 11 Dec 2006 01:47:52 +0000 http://zhoujin.com/post/49/ 本文演示了使用 JS函数 动态插入 UBB 标签到 表单文本域的操作.
本文并没有演示进行 UBB 标签转换为 HTML 标签的操作
说明:
HTML编辑器需要ActiveX支持, 并不是所有浏览器都支持, 比如Opera.

因此对于HTML编辑器和UBB编辑器, 两者我选择 UBB, 因为鄙人习惯使用 OPERA 浏览器, 写的东西当然也得适用于Opera.
话外音: 使用Opera会上瘾, 定力不足者不可乱试:)

目录:
1. Javascript 插入 UBB标签 到表单 文本域 函数

<script type="text/javascript">
//<![CDATA[Subject:Javascript 插入 UBB标签 到表单 文本域 函数 及演示
//表单 必须有 ID, 文件域 name 必须为 content
//------------------------------------start 例子
//<form action="" method="post" name="ubbForm" id="ubbForm">
//<input type="button" value="code" onclick="ubbTag(this.form.id,'[code]')" /><br/>
//<textarea name="content" cols="80" rows="10">aaaaaaaaaa</textarea><br/>
//<input type="submit" name="Submit" value="Submit" />
//<input type="reset" name="Reset" value="Reset" />
//</form>
//-------------------------------------end 例子
function ubbTag(fId, str){
  document.getElementById(fId).content.focus();
  var strEnd=str.replace(/\[/ig,'[/');
  if (strEnd.indexOf('=')>-1){
    strEnd=strEnd.replace(/(.*?)\=.*?(\])/,'$1$2');
  }
  if((document.selection)&&(document.selection.type== "Text")){
    var oStr=document.selection.createRange();
    oStr.text=str+oStr.text+strEnd
  }else{
    document.getElementById(fId).content.value+=str+strEnd
  }
}
//]]>
</script>
<form action="" method="post" name="ubbForm" id="ubbForm">
  <select onchange="ubbTag(this.form.id,'['+this.value+']')">
    <option value="h6">h6</option>
    <option value="h5">h5</option>
    <option value="h4">h4</option>
    <option value="h3">h3</option>
    <option value="h2">h2</option>
    <option value="h1">h1</option>
    <option value="h1" selected="selected">font size</option>
  </select>
  <select onchange="ubbTag(this.form.id,'[color='+this.value+']')">
    <option value="black">color</option>
    <option value="black" style="background-color:black; color:#FFFFFF;">black</option>
    <option value="blue" style="background-color:blue; color:#FFFFFF;">blue</option>
    <option value="fuchsia" style="background-color:fuchsia; color:#FFFFFF;">fuchsia</option>
    <option value="gray" style="background-color:gray; color:#FFFFFF;">gray</option>
    <option value="green" style="background-color:green; color:#FFFFFF;">green</option>
    <option value="lime" style="background-color:lime;">lime</option>
    <option value="maroon" style="background-color:maroon; color:#FFFFFF;">maroon</option>
    <option value="navy" style="background-color:navy; color:#FFFFFF;">navy</option>
    <option value="olive" style="background-color:olive; color:#FFFFFF;">olive</option>
    <option value="orange" style="background-color:orange; color:#FFFFFF;">orange</option>
    <option value="purple" style="background-color:purple; color:#FFFFFF;">purple</option>
    <option value="red" style="background-color:red; color:#FFFFFF;">red</option>
    <option value="silver" style="background-color:silver; color:#FFFFFF;">silver</option>
    <option value="teal" style="background-color:teal; color:#FFFFFF;">teal</option>
    <option value="white" style="background-color:white;">white</option>
    <option value="yellow"style="background-color:yellow;">yellow</option>
  </select>
  <input type="button" value="url" onclick="ubbTag(this.form.id,'[url]')"/>
  <input type="button" value="img" onclick="ubbTag(this.form.id,'[img]')"/>
  <input type="button" value="email" onclick="ubbTag(this.form.id,'[email]')"/>
  <input type="button" value="code" onclick="ubbTag(this.form.id,'[code]')" />
  <input type="button" value="quote" onclick="ubbTag(this.form.id,'[quote]')"/>
  <input type="button" value="cite" onclick="ubbTag(this.form.id,'[cite]')"/>
  <input type="button" value="linenum" onclick="ubbTag(this.form.id,'[linenum]')"/>
  <input type="button" value="b" onclick="ubbTag(this.form.id,'[b]')"/>
  <input type="button" value="left" onclick="ubbTag(this.form.id,'[align=left]')"/>
  <input type="button" value="center" onclick="ubbTag(this.form.id,'[align=center]')"/>
  <input type="button" value="right" onclick="ubbTag(this.form.id,'[align=right]')"/>
  <input type="button" value="textarea" onclick="ubbTag(this.form.id,'[textarea]')"/>
  <input type="button" value="pre" onclick="ubbTag(this.form.id,'[pre]')"/>
  <input type="button" value="sub" onclick="ubbTag(this.form.id,'[sub]')"/>
  <input type="button" value="sup" onclick="ubbTag(this.form.id,'[sup]')"/>
  <input type="button" value="abbr" onclick="ubbTag(this.form.id,'[abbr]')"/>
  <input type="button" value="address" onclick="ubbTag(this.form.id,'[address]')"/>
  <input type="button" value="dl" onclick="ubbTag(this.form.id,'[dl][dd]')"/>
  <input type="button" value="dt" onclick="ubbTag(this.form.id,'[dt]')"/>
  <input type="button" value="dd" onclick="ubbTag(this.form.id,'[dd]')"/>
  <input type="button" value="nl" onclick="ubbTag(this.form.id,'[nl][li]')"/>
  <input type="button" value="ol" onclick="ubbTag(this.form.id,'[ol][li]')"/>
  <input type="button" value="ul" onclick="ubbTag(this.form.id,'[ul][li]')"/>
  <input type="button" value="li" onclick="ubbTag(this.form.id,'[li]')"/>
  <input type="button" value="floatleft" onclick="ubbTag(this.form.id,'[float=left]')"/>
  <input type="button" value="floatright" onclick="ubbTag(this.form.id,'[float=right]')"/>
  <input type="button" value="tagLink" onclick="ubbTag(this.form.id,'[taglink]')"/>
  <input type="button" value="glLink" onclick="ubbTag(this.form.id,'[gllink]')"/><br/>
  <textarea name="content" cols="80" rows="10">aaaaaaaaaa</textarea><br/>
  <input type="submit" name="Submit" value="Submit"/>
  <input type="reset" name="Reset" value="Reset"/>
</form>

Tags - , , , , , ]]> http://zhoujin.com/post/48/ <![CDATA[一直邮件发送的程序！很强的]]> chirs <> Thu, 23 Nov 2006 01:58:41 +0000 http://zhoujin.com/post/48/
/**
* 邮件发送组件,具体的使用方法参照该类的main方法
* <code>
*
        String mailHost = "smtp.163.com";  //发送邮件服务器地址
        String mailUser = "user1";      //发送邮件服务器的用户帐号
        String mailPassword = "password1";  //发送邮件服务器的用户密码
        String[] toAddress = {"user1@163.com"};
        //使用超文本格式发送邮件
        MailSender sendmail = MailSender.getHtmlMailSender(mailHost, mailUser,mailPassword);
        //使用纯文本格式发送邮件
        //MailSender sendmail = MailSender.getTextMailSender(mailHost, mailUser,mailPassword);
        try {
            sendmail.setSubject("邮件发送测试");
            sendmail.setSendDate(new Date());
            String content = "<H1>你好,中国</H1><img src=\"http://www.javayou.com/images/logo.gif\">";
            //请注意如果是本地图片比如使用斜杠作为目录分隔符,如下所示
            content+="<img src=\"D:/EclipseM7/workspace/JDlog/dlog/images/rss200.png\"/>";
            sendmail.setMailContent(content); //
            sendmail.setAttachments("E:\\TOOLS\\pm_sn.txt");
            sendmail.setMailFrom("user1@163.com","发送者");
            sendmail.setMailTo(toAddress, "to");
            //sendmail.setMailTo(toAddress, "cc");//设置抄送给...
            //开始发送邮件
            System.out.println("正在发送邮件，请稍候.......");
            sendmail.sendMail();
            System.out.println("恭喜你，邮件已经成功发送!");
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        
* </code>
* @author Liudong
*/
public abstract class MailSender extends Authenticator {

    private String username = null;    //邮件发送帐号用户名
    private String userpasswd = null;  //邮件发送帐号用户口令
    protected BodyPart messageBodyPart = null;
    protected Multipart multipart = new MimeMultipart("related");
    protected MimeMessage mailMessage = null;
    protected Session mailSession = null;
    protected InternetAddress mailToAddress = null;

    /**
     * 构造函数
     * @param smtpHost
     * @param username
     * @param password
     */
    protected MailSender(String smtpHost, String username, String password) {
        this(smtpHost,25,username,password);
    }
    /**
     * 构造函数
     * @param smtpHost
     * @param smtpPort
     * @param username
     * @param password
     */
    protected MailSender(String smtpHost, int smtpPort, String username, String password) {
        this.username = username;
        this.userpasswd = password;
        Properties mailProperties = System.getProperties();
        if(smtpHost!=null)
          mailProperties.put("mail.smtp.host", smtpHost);
        if(smtpPort>0 && smtpPort!=25)
            mailProperties.put("mail.smtp.port", String.valueOf(smtpPort));
        mailProperties.put("mail.smtp.auth", "true"); //设置smtp认证，很关键的一句
        mailSession = Session.getDefaultInstance(mailProperties, this);
        mailMessage = new MimeMessage(mailSession);
        messageBodyPart = new MimeBodyPart();
    }
    /**
     * 构造一个纯文本邮件发送实例
     * @see getTextMailSender(String smtpHost, int smtpPort, String username, String password)
     * @param smtpHost
     * @param username
     * @param password
     * @return
     */
    public static MailSender getTextMailSender(String smtpHost, String username, String password) {
        return getTextMailSender(smtpHost,25,username,password);
    }
    /**
     * 构造一个纯文本邮件发送实例
     * @param smtpHost  SMTP服务器地址
     * @param smtpPort  SMTP服务器端口
     * @param username  SMTP邮件发送帐号
     * @param password  SMTP邮件发送帐号对应的密码
     * @return
     */
    public static MailSender getTextMailSender(String smtpHost, int smtpPort, String username, String password) {        
        return new MailSender(smtpHost,smtpPort,username,password) {
            public void setMailContent(String mailContent) throws MessagingException {
                messageBodyPart.setText(mailContent);
                multipart.addBodyPart(messageBodyPart);
            }            
        };        
    }
    /**
     * 构造一个超文本邮件发送实例
     * @see getHtmlMailSender(String smtpHost, int smtpPort, String username, String password)
     * @param smtpHost
     * @param username
     * @param password
     * @return
     */
    public static MailSender getHtmlMailSender(String smtpHost, String username, String password) {
        return getHtmlMailSender(smtpHost,25,username,password);
    }
    /**
     * 构造一个超文本邮件发送实例
     * @param smtpHost  SMTP服务器地址
     * @param smtpPort  SMTP服务器端口
     * @param username  SMTP邮件发送帐号
     * @param password  SMTP邮件发送帐号对应的密码
     * @return
     */
    public static MailSender getHtmlMailSender(String smtpHost, int smtpPort, String username, String password) {
        return new MailSender(smtpHost,smtpPort,username,password) {
            private ArrayList<String> arrayList1 = new ArrayList<String>();
            private ArrayList<String> arrayList2 = new ArrayList<String>();

            public void setMailContent(String mailContent) throws MessagingException {
                String htmlContent = getContent(mailContent);
                messageBodyPart.setContent(htmlContent, CONTENT_TYPE);
                multipart.addBodyPart(messageBodyPart);
                //调用处理html文件中的图片方法
                processHtmlImage(mailContent);
            }

            //处理html页面上的图片方法如下：
            private void processHtmlImage(String mailContent) throws MessagingException {
                for (int i = 0; i < arrayList1.size(); i++) {
                    messageBodyPart = new MimeBodyPart();
                    DataSource source = new FileDataSource((String) arrayList1.get(i));
                    messageBodyPart.setDataHandler(new DataHandler(source));
                    String contentId = "<" + (String) arrayList2.get(i) + ">";
                    messageBodyPart.setHeader("Content-ID", contentId);
                    messageBodyPart.setFileName((String) arrayList1.get(i));
                    multipart.addBodyPart(messageBodyPart);
                }
            }

            //处理要发送的html文件，主要是针对html文件中的图片
            private String getContent(String mailContent) {
                try {
                  Parser parser = new Parser();
                  parser.setInputHTML(new String(mailContent.getBytes(), ISO8859_1));
                    //Parser parser = Parser.createParser(new String(mailContent.getBytes(), ISO8859_1));
                    Node[] images = parser.extractAllNodesThatMatch(HtmlNodeFilters.imageFilter).toNodeArray();
                    for(int i=0;i<images.length;i++) {
                        ImageTag imgTag = (ImageTag) images[i];