2008年12月14日

这几天在看郎咸平的《谁在谋杀中国经济》，这本书我基本看过一遍了，认为全书的重点在于中华文化的四大茫然，整本书都是围绕这四大茫然展开论述，中华文化的四大茫然如下：
茫然之一：就知道赚钱
茫然之二：不了解世界
茫然之三：不了解别人为什么那么看你
茫然之四：不了解自己的缺点

大家有时间可以看看这本书，我觉得写的不错，至少我自己看完深有感触，我觉得完全可以将这几点套用到我们生活的很多方面，比如对于我们搞IT的技术人员来说，我认为现在很多人也存在四大茫然：

茫然之一：只知道完成任务。也许是我年龄大了点，但我觉得现在很多小朋友，尤其是85年以后出生的，工作的时候只是在完成任务，事情做完了，有时也不测试，或者就是匆匆测试，匆匆结束，并没有好好的想为什么这件事老大要让我这样做，这样做有什么好处，会不会有缺点，我是不是有更好的方法。当你不去想的时候，意味着你少了很多提高的机会。

茫然之二：不追究为什么。很多人做事情就象第一条说的那样，只是完成任务，并不去想其中的原理是什么。面试过很多人，对于目前工作两三年的大部分人来说(当然我面试的不是好的学校毕业的，基本学校为中等偏下点)，一旦涉及到Spring、Hibernate、Struts等框架深入点东西的时候，大都回答不上来，只是对框架能熟练应用而已。这样够么？计算机的很多知识，当你熟悉了其运作原理，框架对于你来说，只是手到擒来，看看学学就会用了。我问过好几个同事，平时晚上回去都干嘛，很多人都回答我晚上回去看看电视，稍微看看书就睡觉了。我有点惊讶，我想如果你想成为一个技术高手，一个能拿高薪的程序员，你又没有天份，又不付出超过常人的努力，凭什么你比别人强呢？

茫然之三：不善于总结。很多人（又是很多人）过着做一天和尚撞一天钟的日子，日子一天一天过去，基本不去总结，只是过了好长一段时间会发觉，原来最近我啥也没有进步，啥也没学到，还是老样子。知识在于积累，你只有不断总结，知识才能更好的积累，才能更好的为你服务。

茫然之四：没有明确的目标。一个人没有目标就决定了他不会有长足的进步。你都没有想过自己要成为一个架构师，一个项目经理，一个部门经理，一个技术总监，都没有想过要成为这样的人需要具备什么样的条件，你怎么可能知道自己欠缺什么？需要补充什么呢？长远目标要明确，然后根据长远目标进行分析，我要达到这样的目标，还有什么欠缺，据此制定短期目标，短期目标一定要可实现可操作。这样随着你目标的一步一步实现，你各方面的能力也随之提高了。

写了几点，也作为对自己的鞭策。

2010年已经过去一个月了，赶在农历春节前列一下今年的读书清单，不能总把精力放在工作中了，也需要补充点新知识了，否则没有新东西能贡献出来了。

1、《OSGI原理与最佳实践》，结合这本书并研究SpringDM，做一些实例。

2、《SQL语言艺术》

3、《Oracle9i&10g编程艺术》

4、《架构之美》

5、《UML和模式应用》

6、《UML彩色建模》

7、《领域驱动设计与模式实战》

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

9、《软件开发的边界》

10、《软件随想录》

11、《走出软件作坊》

就这么多了，9、10、11去年都看过一遍了，但好多地方粗粗过了一下，还要仔细阅读。

另外也对自己提个要求，看书要做读书笔记。

2010年-我的读书年！

摘自《软件随想录》

看了软件随想录中下面一段话，觉得非常棒，作为一名软件从业人员，不一定有机会能实现描述中的优秀软件产品，但这样的理念需要贯穿我们每个人的心田，时刻记在心中：

【创造一个有使用价值的软件，你必须时时刻刻都在奋斗，每一次的修补，每一个功能，每一处小小的改进，你都在奋斗，目的只是为了再多创造一点空间，可以再多吸引一个用户加入。没有捷径可走。你需要一点运气，但是这不取决于你是否幸运。你之所以会有好运气，那是因为你寸土必争。

每天你前进一小步，将一件东西做得比昨天好一点点。这样的改进几乎看不出可以让谁获益，几乎没有变化。但是，你前进了一小步。

有无数个要做的这样微小的改进。

为了发现可以改进的地方。你必须有一个思维定势，始终如一的用批判的眼光看世界。随便找一样东西，如果你看不出它的缺点，那么你的思维转型还没有成功。当你成功的时候，你身边亲密的人会被你逼得发疯。你的家人恨不得杀了你。当你步行上班的时候，看到一个司机漫不经心地开车，你几乎用了所有的意志力才勉强忍不住冲上去告诉那个司机，他这样开车差点儿要了旁边坐在轮椅上的那个可怜小孩的命。

当你改正了一个又一个这样的小细节后，当你磨光、定型、擦亮、修饰你的产品的每一个小边角后，就会有神奇的事情发生。厘米变成分米，分米变成米，米变成了千米。你最后拿出来的是一件真正优秀的产品。它第一眼就让人觉得震撼，出类拔萃，工作起来完全符合直觉。就算100万个用户中有一个用户某天突然要用到一个他100万次使用中才会用到一次的罕见功能，他发现了这个功能不仅能用，而且还很没：在你的软件中，即使是看门人的小屋都铺着大理石的地板，配有实心的橡木门和桃花心木的壁板。

就是在这个时候，你意识到这是一个优秀软件。】

http://www.insideria.com/2009/05/flex-4-custom-layouts.html

http://www.insideria.com/2009/10/easy-flex-skinning-with-firewo.html

在Flash Builder 4 Beta 2版本中，使用mxml方式实现state的切换有了很大改进，使用起来更方便，具体可参见下文：

http://onflex.org/learn/fx4/index.php?page=States

看完这篇文章后，想到一个问题，如何用编程的方式实现切换呢，找了参考资料，实现了一个例子，代码如下：

开发环境：Flash Builder 4 Beta2

    这是前几天在别人的BLog上看到的一幅图，觉得不错，基本涵盖了IT人员需要掌握的基础知识这块，从这幅图中可以看出语言并不重要，关键是要搞明白整个环节，这样遇到任何问题就能有目的、有方法的学习了。

1、下载Ruby并安装，下载地址：http://rubyforge.org/frs/?group_id=167

下载了1.8.6-27 Release Candidate 2（ruby186-27_rc2.exe）版本

2、在windows的命令行下，输入 ruby –v，检查ruby是否正确安装，应该出现如下信息：

ruby 1.8.6 (2008-08-11 patchlevel 287) [i386-mswin32]

3、安装rails，执行gem install rails命令，安装成功后，执行rails -v检查。

我安装了Rails2.3.2版本。使用gem install -version rails可以指定安装的rails版本，具体如何使用gem，可以用gem help install查看帮助。

参考：Ruby On Rails（ROR）安装（http://enjoylog.cn/?p=8）

装好了便到Ruby On Rails的官方网站（http://rubyonrails.org/），找到了

Getting Started with Rails(http://guides.rubyonrails.org/getting_started.html)

开始一步一步follow up。

RubyOnRails的中文站上的翻译文档没有完全跟进，还是看英文的吧。

我使用的是MySQL的数据库，操作系统：Vista。

到创建POSTS应用的时候遇到了问题，创建数据后数据库中有数据，但是到Listing posts界面无法查看，总是报错。

网上Google了一下，果然有人遇到相同的问题，参照了如下解决方案，到

http://instantrails.rubyforge.org/svn/trunk/InstantRails-win/InstantRails/mysql/bin/ 上下载了libmySQL.dll文件放到RUBY_HOME/bin/目录下，问题解决。

参考：升级2.2后mysql驱动的问题（http://www.javaeye.com/topic/283871?page=1）

感叹一下，当Listing Posts这个CRUD小应用跑起来后，觉得Ruby On Rails的开发是比Java开发要快一些，看了一下它生成的代码，貌似也不多。

今天晚了，明天继续。

    最近在做一个很小的项目的功能改进，小小的项目中原来连接的是MySQL数据库，现在需要新连接一个数据库（Oracle），仅仅从一张表查询数据即可，没有添加、修改、删除等等功能。本来这个小小的项目中用的是Hibernate，现在又要增加一个数据库连接，觉得配置起来有点麻烦，忽然想起来，我干吗还要用Hibernate呢，直接用JDBC不也挺好使么，想了便做，果然写起JDBC来，很是快捷，一会就搞好了。

    做好了以后，忽然觉得有点迷茫，感觉不用Hibernate不也挺好的么，咱为什么现在开口闭口都是Hibernate呢，于是便有了今天的题目。

    很久以前没有Hibernate的时候：

    第一阶段：我们写程序都是直接用JDBC，甚至在JSP页面中直接去createConnection，然后执行查询，输出到页面。

    第二阶段：后来觉得每次都是创建一个连接，好像效率不高，于是看了别人的介绍，要用数据库连接池，好的，那便用数据库连接池吧，每次都从pool中获得一个Connection，然后查询数据。

    第三阶段：用了连接池，还是效率不高，那怎么办呢？用缓存吧，自己实现缓存？可以，也可以用开源的缓存框架。

    第四阶段：到了OO大流行的时代了，一切都要OO，恰逢Hibernate降临人世，于是一切都用Hibernate来实现了，其实同期还是有不少其它ORMAP框架的，比如（TOPLINK、JDO、IBatis等，IBatis国内用的还比较多，另外两个好像用的比较少）。

    第五阶段：忽然EJB大流行，事务的概念被广为传播（并不是原来没有事务的概念，只是实现起来比较麻烦），借助EJB的广为传播，Spring+Hibernate的组合也慢慢占据了大半市场。此时事务用Spring AOP的声明式事务来解决，缓存可以用开源的缓存框架（已经和Hibernate无缝集成了），数据库连接池也是通过配置的方式在SpringContext.xml文件中配置，貌似一切都很完美。

    真的到了第五阶段，一切是不是真的完美了呢，如果一个很小的应用，需要从好几个数据库查询数据，但是每个数据库仅需要查询那么一两张表的数据，偶尔添加、删除几条数据，数据量也不大，此时我们是不是还用第一阶段的方式会更好呢，好像有时配置多数据源也不是那么方便的事情。或者使用Spring中的JDBCTemplate，貌似也不错。

    再往后看，难道Spring+Hibernate的组合就天下无敌了么？难道就没有新的框架了么？前段时间，JavaEye上关于充血模型、贫血模型的讨论吸引了多少眼球，以后是不是会有这么一个框架用于实现充血模型呢？

   说了这么多，最终只是想说明白这么一句：用恰当的技术做恰当的事情，这真是一个艰难的选择……，至于未来，更是迷茫，因为我们只是跟随者，而不是领导者。

前两天出差在外，利用空余时间将《深入浅出EXT JS》这本书的前五章翻了一遍，后面的章节粗粗浏览了一下，觉得这本书写的不错，写下自己的一点感悟：

1、适合的读者

a、是一名Java开发程序员，做过WEB开发

b、对Ajax开发的基础知识有所了解

2、书评：

        这本书我觉得应该改成这个名字：《EXT JS CookBook》，可能使得书的内容和名称更贴切，呵呵。

        书中对Ext JS的基础类、Grid、Form、Tree、布局管理器、数据获取等各方面都做了详细的描述，基本上开发中需要用到的知识点，在书中都会提到，而且书中的很多例子和实际工作还是非常贴切的，对于工作中需要用到EXT JS或者需要学习EXT JS的程序员来说还是会很有帮助的。

        最后提点缺点，这本书中对EXT JS的知识点都做了比较详细的描述，但是缺乏对EXT JS的框架的深入分析。

前两天在InfoQ上看到一篇文章：利用Clear Toolkit连接Flex与Java开发，今天下载了说明文档粗略了翻了一遍，Clear Toolkit包含五个部分，分别是：

• Clear Data Builder，这是个Eclipse插件，可以根据SQL语句或Java数据传输对象为BlazeDS或LCDS自动生成CRUD应用。
• DTO2Fx，该插件会根据Java类型自动生成对应的ActionScript类。
• Log4Fx是个构建于Flex logging API之上的Eclipse插件，它会自动化日志处理并且更加灵活，也更加友好。
• Fx2Ant插件会为Flex Builder项目生成优化的Ant构建脚本。
• clear.swc是个增强的Flex组件库。

暂时用不到这个工具，记录留待备查。

这篇Blog是原来写在别的地方的，今天将其转到BlogJava上来。
-------------------------------------------------------------------------------

今天仔仔细细的看了一下Hibernate的缓存，并做了实例实践了一把。google一下，网上的教程、文章很多。
自己小结一下：

Hibernate的缓存分为：

• 一级缓存：在Session级别的，在Session关闭的时候，一级缓存就失效了。
• 二级缓存：在SessionFactory级别的，它可以使用不同的缓存实现，如EhCache、JBossCache、OsCache等。

缓存的注释写法如下，加在Entity的java类上：

• @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)

缓存的方式有四种，分别为：

• CacheConcurrencyStrategy.NONE
• CacheConcurrencyStrategy.READ_ONLY，只读模式，在此模式下，如果对数据进行更新操作，会有异常；
• CacheConcurrencyStrategy.READ_WRITE，读写模式在更新缓存的时候会把缓存里面的数据换成一个锁，其它事务如果去取相应的缓存数据，发现被锁了，直接就去数据库查询；
• CacheConcurrencyStrategy.NONSTRICT_READ_WRITE，不严格的读写模式则不会的缓存数据加锁；
• CacheConcurrencyStrategy.TRANSACTIONAL，事务模式指缓存支持事务，当事务回滚时，缓存也能回滚，只支持JTA环境。

另外还有如下注意事项：

1、查询缓存需要在Query的相应方法执行前加上这么一句：

query.setCacheable(true);

在使用Hibernate时，获得的query有setCacheable方法，可以设置使用缓存，但当使用JPA时，javax.persistence.Query并没有setCacheable方法，此时如果JPA的实现是Hibernate时，可以将其进行如下转化，再调用setCacheable方法（如果JPA的实现是其它ORMAP框架，就不知道怎么做了）。

2、还有就是查询缓存的查询执行后，会将查询结果放入二级缓存中，但是放入的形式是以ID为Key，实例作为一个Value。

3、hibernate的配置文件中需加入如下信息：

今天在Javaeye的新闻频道看到一个界面原型绘制工具，叫做“wireframesketcher”，下载试了试，感觉有如下几个好处：

1、使用方便，可以很容易的做tree和table，比visio中的tree和table好用

2、集成在eclipse中，对于开发人员来说用起来更直接

3、其界面原型文件为xml格式，可以使用比较工具比较

唯一的缺点：

不是免费开源的工具，但是现在可以申请免费的license

随便画了一个图，如下：

感兴趣的兄弟姐妹们可以到如下地址看看：

http://wireframesketcher.com/index.html

由于要写一个Spring的培训教材，要做Spring的事务样例，于是开始写样例，写好了一测，控制台有SQL输出，数据库却查询不到数据，查亚查亚，花了一个多小时，原来是获取的Service不是经过代理的Service，自然事务不起作用，数据库里就没有数据了，鄙视一下自己。

配置文件样例如下（已经修改了dao和service的命名，减少了写错的可能性，以后命名问题一定要注意）：

    给自己做的这个程序起了个名字叫EasyWork，代码可以从Google Code上下载，具体地址如下：

  http://easywork.googlecode.com/svn/trunk/

  由于时间关系，这个程序还存在不少问题，所以只能供大家参考，有问题不要骂我就行了:)

  简要使用说明：

  1、开发环境+运行环境：MyEclipse6.0，JDK1.5，Tomcat6.0.14，MySQL5.0

  2、准备好上述环境后，使用下载代码sql目录中的easywork_init.sql脚本创建数据库表和初始数据。

  3、将项目导入Eclipse后，运行Tomcat（此过程就不详细描述了）。

  4、使用http://localhost/easywork/system/login.jsp访问登录页面，目前还没有做index.html，默认用户名/密码：admin/1。

  存在问题如下：

  1、任务管理功能还没有完全完成，日志记录还没有做。

  2、超时或者没有登录访问页面时，只是报不能访问的异常，没有转入登录页面。

  3、对资源类型（菜单、URL、字段、操作）的访问限制还没有做。

  4、很多界面的输入信息校验没有做。

  5、基本没有美工。

  6、总而言之，目前这个项目中的代码只能做Struts2 + ExtJS如何使用的借鉴:)

    很近没有更新BLog了，这一阵子忙着学习Struts2和ExtJS，使用这两者做了一个小程序，使用RBAC实现了基本的权限管理功能，还做了一个任务管理和日志记录，任务管理用于记录当前需要处理的事情，日志记录用于记录每天的工作情况。

    用下来Struts2和ExtJS还是挺好用的。先贴几张图，后续再把学习过程中遇到的问题整理出来。

任务管理

添加组

添加权限

添加角色

    由于前段时间使用JSF做了一个项目，不少使用JSF的兄弟们对JSF评价并不好，因此在学习的过程中一直在想，JSF究竟是不是应该继续学习继续研究使用下去，在看完Seam In Action的第三章后，这个星期又对Struts2简单学习了一下，终于决定结束JSF和JBoss Seam的学习了。

    因为从JSF的学习和Struts2的学习对比中明显觉得JSF复杂，对于一个技术力量不是非常强的项目组来说，使用JSF当你遇到一些问题时，绝对是一件痛苦的事情。

    从自己的实践中觉得JSF至少有两个致命伤：

    1、觉得JSF貌似把简单的事情搞得复杂化了，在传统的MVC框架如Struts中，从request中获取param很容易，也可以将param封装为对象，在JSF中，希望将这一切都模型化，一切都以组件为中心，类似于Swing的架构，但是http的无状态以及web的本质，使得一般JSF只能将组件树存放在服务端，同时又不能象CS程序那样方便的查看组件的状态、属性等信息。对于通常情况来说，JSF将其封装的很好，不用我们开发者操心，但是当遇到一些问题时，对于开发者想去调试查看问题时，问题就显得很复杂了。

    2、JSF的自定义组件感觉超复杂，难度应该比当年自定义JSP标签更要高，试想一下，如果哪个组件不合意了，想改一下，还是比较困难的，除非对JSF组件有相当的深入了解。

    顺便把项目中遇到的一个RichFaces的缺点列出来：

    RichFaces在生成组件的html时，大量使用了Div，曾经有过一个页面有1千多行（在一个table中），页面上还有一个RichFaces的下拉菜单，从而导致菜单响应非常之慢，后来只有将rich:datatable换为普通的html:table，就没有问题了。

    再看看Seam In Action中总结的JSF的缺点：

    1、在JSF中初次请求的处理流程太过简单，而后续请求则执行了完整的复杂的处理流程。在JSF中假设第一个调用应该是在页面被渲染后执行，但实际中有时我们需要在第一次请求时就执行某些操作。在JSF中缺少象Struts中的Controller。

    2、所有的请求都是POST。浏览器处理POST请求是比较草率，当用户执行了一个JSF Action操作后，点击浏览器的刷新按钮时，浏览器会询问用户是否重新提交，这会令用户非常困惑。

    3、仅仅拥有简单基础的页面导向机制。

    4、过度复杂的生命周期。

    JBossSeam宣称对于JSF存在的缺点都提供了解决方法，但是有一种更复杂的感觉。

    在Seam中，生成选择的项目时，有EAR和WAR的选项，如果选择了EAR选项，那么Seam会生成四个项目，分别为war、ear、ejb、test四个类型的项目。有一次我将生成的项目从一个目录拷贝到另一个目录，切换了Eclipse的workspace，此时问题来了，ejb项目提示编译错误，提示无法找到某些class，找来找去找来找去......后来将项目关闭了一下，再打开错误提示就没有了。

    由这个问题我忽然想到，使用Seam集成JSF、EJB是不是太重量级了，如果采用EJB作为替代普通的POJO，对于一个小型的项目组来说，一般的规模就是三至五个人（我个人的理解），开发人员本来就不多，还要面对Seam划分的四个项目，好像比较繁琐，当然采用war模式另当别论。

    相比较而言，这个星期看了一些Struts2的资料，觉得Struts2的架构非常清晰，易于理解。

    翻了很早之前的JavaEye上的一个帖子，提到JSF是面向开发工具的，如果能做到象VB那样，就大有前途了，4年过去了，不要提JSF的开发工具了，就是Java各个方面的GUI开发工具，又有哪个能和VB相比呢，看来选择JSF作为一个方向不是一个好选择........还是及早放弃吧，哎...

    最后我觉得可以用这么一句话可以形容JSF，看起来很美，用起来不爽。

这个事情去年做过一次，不过没有留下记录，今天又要做一次，记录下来，呵呵

环境：

Spring版本为1.2，Tomcat为5.5.26，JDK为Jdk1.5.0_11。

1、下载Axis1.4，解压后将其jar文件添加到web项目的lib目录中。

2、配置Axis Servlet，在web.xml文件中加入如下信息：

 
3、编写java类，样例如下。

接口：

实现类：

注意实现类需要继承ServletEndpointSupport类，该类是由Spring提供的。

4、配置service-config.wsdd。

 
5、测试web service服务，代码如下。

至项目的WEB-INF目录下，执行如下命令：

Java -Djava.ext.dirs=lib org.apache.axis.wsdl.WSDL2Java http://localhost:8080/axis/services/interchangeDataService?WSDL

会在WEB-INF目录中生成四个JAVA文件，它们分别是：

• InterchangeDataServiceImpl.java   定义了Web服务接口，接口中的方法与InterchangeDataService中的方法一致。
• InterchangeDataServiceImplService.java 定义了用于获取Web服务接口的方法。
• InterchangeDataServiceImplServiceLocator.java 接口InterchangeDataServiceImplService的具体实现。
• InterchangeDataServiceImplSoapBindingStub.java Web服务客户端桩，通过该类与服务器交互。

最后编写一个Main方法，调用如下方法即可进行测试：

    上次使用Seam自动生成了一个CRUD的例子，后来想还是自己白手起家做一个例子看看，于是开始动手。

    首先使用JBossTools工具生成项目，在生成项目的向导中，如果项目类型选择ear，则会生成四个项目，分别对应war、ear、ejb、test，觉得这样太过繁琐，还是选择war类型，又想要不使用tomcat作为运行服务器吧，因为JBoss也不太熟悉。没想到这一试倒试出问题来了，如果完全使用向导生成项目，选择tomcat作为运行服务器，则项目根本无法运行起来，总是提示缺少这个jar，那个jar。好，又换回JBoss，没问题了。仔细看了一下，原来在自动生成项目的WebContent/WEB-INF/lib目录中，只有大概十几个jar，连Hibernate的jar都没有，而在JBoss的Server/default/lib目录下则什么jar都有，怪不得不出错。

第一个教训：还是先使用JBoss作为运行环境，等整个Seam都搞熟了，再配一个Tomcat的运行环境。

    继续，将原来项目中的一个通用DAO和一个UserService拷贝过来，代码如下，启动服务器报错。分别为如下错误信息：

第二个错误解决：Caused by: java.lang.IllegalArgumentException: @PersistenceContext may only be used on session bean or message driven bean components: genericDao

    既然提示@PersistenceContext只能用在SessionBean中，因为原来的代码是使用的Spring框架，想了好长时间，在WebContent/WEB-INF/component.xml中看到这么一段，那么是不是通过@In来注入entityManager呢，修改@PersistenceContext为@In，编辑器自动提示没有发现名称为em的Component（这点好像不错），于是再修改为@In("entityManager") ，重启服务器，该问题解决。

第三个错误解决：Caused by org.jboss.seam.RequiredException with message: "@In attribute requires non-null value: userService.genericDao"

    将UserService中的@In修改为@In(create = true, required = true)解决此问题。

    解决上述几个问题后，自己的例子终于运行起来了 :-)

    下一篇关于Seam In Action中对JSF的介绍及Seam如何增强JSF。

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

    项目生成的代码被分为两个目录，分别为Action和Model目录，检查JBoss中项目部署的目录，发觉Action目录下的代码编译生成的class文件被存放至WEB-INF/dev目录下，Model目录下的代码编译生成的class文件被存放至WEB-INF/classes目录下，google了一下，发现在Seam Reference中提到这是Seam的增量式重部署，支持对JavaBean组件的增量重部署，可以加快编辑/编译/测试的速度。

代码如下：

public interface GenericDao {
    public Object get(Class clazz, Serializable id);
    public void save(Object object);
    public void update(Object object);
    public void remove(Class clazz, Serializable id);
    public void remove(Object obj);
   
}

@Name("genericDao")
public class GenericDaoImpl implements GenericDao {
    @PersistenceContext  ---->   @In("entityManager")
    private EntityManager em;

    public Object get(Class clazz, Serializable id) {
        if (id == null)  return null;
        else return em.find(clazz, id);
    }
   
}

public interface UserService {
    public void findAllUsers();
}

@Name("userService")
public class UserServiceImpl implements UserService, SecurityUserService {

    @In ----> @In(create = true, required = true)
    protected GenericDao genericDao;
    private List<User> resultList = null;

    public List<User> getResultList() {
        if (resultList == null) {
            this.findAllUsers();
        }
        return resultList;
    }

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

    public void findAllUsers() {
        String hql = "from User order by userCode";
        resultList = this.genericDao.query(hql);
    }
}

// 实体类
@Entity
@Table(name = "USER")
public class User implements IUser, Serializable {
    // 用户编码
    @Id
    private String userCode;

    // 用户姓名
    private String userName;
}

通过这个实践，小结一下：

1、发觉Seam确实简化了JSF开发，但由于它涉及的新东西相对较多，与传统的SSH走的路线不太一致，还是觉得其学习曲线比较陡峭，需要对Seam熟练掌握后（包括开发环境的搭建等）才能真正提高开发效率。

2、Seam提供了IOC的功能，有时需要跳出Spring，从一个新的角度去审视Seam。

    这个星期的后半周主要搞了kettle的试验，做了两个例子出来，在后续工作中这两个例子应该也能派上用场，本来以为kettle的文档不多，后来单独下载了kettle的doc压缩包，发觉里面的内容还是不少的，真要将kettle搞熟的话，这些文档还是需要仔细研读一番的。另外kettle doc解压后文档目录挺奇怪的，都是数字命名的目录名，不知有啥具体含义。

    下周的学习重点还是要转回到JBoss Seam中了 :-)

需求：

kettletest1数据库中有table_source数据表，结构如下：

1. Id                主键
2. t_id             数据时间
3. part_id        实例ID
4. yg               数据字段1
5. wg              数据字段2

该表中的数据对于不同的实例ID，一分钟一条数据，t_id字段表示数据的时间，精确到分钟。

kettletest2数据库中有table_target数据表，结构如下：

1. Id                     主键
2. marketdate      数据日期，格式为 yyyy-MM-dd
3. pointtime        时间，格式为 HH:mm
4. pointnumber   时间的数字表示，00:01表示为1，00:00表示为1440
5. plantcode        实例Code
6. yg                    数据字段1
7. wg                   数据字段2

需定期将table_source表中的数据获取至table_target表中，并进行如下处理：

1、将t_id数据时间字段拆分为三个字段，分别为marketdate、pointtime、pointnumber。

        a、marketdate取t_id的日期部分。
        b、pointtime取t_id的时间部分。
        c、pointnumber为时间的数字表示，等于hour*60+minute。
        d、但当t_id的时间为某日的00:00时，需将其转化为24:00，并且marketdate需取日期的前一天。如t_id为2008-12-04 00:00，则marketdate为2008-12-03，pointtime为24:00，pointnumber为1440。

2、将part_id字段映射为plantcode字段，并根据如下规则进行转换：
        part_id                 plantcode
         3206                        P01
         3207                        P02
         3208                        P03

测试中使用的数据库均为mysql数据库。

实战：

整个转换工作共分为三个步骤，如下图：

1、定义需获取的数据的日期

2、删除table_target表中已有数据，注意一定要将“执行SQl语句”面板中的“变量替换”要选上，否则SQL语句中的变量不会被替换，我刚开始没注意到这个地方，找问题找了半天。

3、获取table_source中的数据，并将其插入table_target表

        3-1、获取table_source表的数据

        3-2、值映射

        3-3、字段选择

        3-4、对t_id字段进行处理，增加了pointnumber字段。在这一步骤中发现kettle的一个bug，就是不能在JavaScript中使用str2date函数，错误的具体信息参见：http://jira.pentaho.com/browse/PDI-1827。这个问题也折腾了好长时间，刚开始怎么也想不通这个函数使用时怎么会报错呢，后来只好从字符串中截取年、月、日信息。

       该步骤中还存在另外一个使人困惑的问题，就是点击“测试脚本”按钮，会报错，但是执行job和transformation时则不会报错。

        3-5、增加pointnumber字段至输出结果中

        3-6、插入数据至table_target表

3-4步骤中的JavaScript代码如下：

至此，整个转换工作完成，小结一下：

    如果对kettle等etl工具比较熟悉的话，使用etl工具进行数据转换、抽取等事情还是比较方便的，比起写程序还是有优势的。但是这个转换过程中遇到的kettle的两个bug比较让人头疼，觉得kettle好像还不是很稳定。