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

1.属性的动态getter、setter

BeanUtils.getProperty(myBean,"code");

BeanUtils.getProperty(orderBean, "address.city");

BeanUtils.getProperty(orderBean, "customers[1].name");

2.BeanCompartor 动态排序

List peoples = ...; // Person对象的列表
Collections.sort(peoples, new BeanComparator("age"));

如果要支持多个属性的复合排序，如"Order By lastName,firstName"

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

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

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

   经常要从request,resultSet等对象取出值来赋入bean中，如果不用MVC框架的绑定功能的话，下面的代码谁都写腻了。

   String a = request.getParameter("a");
   bean.setA(a);
   String b = ....
   bean.setB(b);
   ......

不妨写一个Binder自动绑定所有属性:

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

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

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


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

     public static Object invokeConstructor(Class klass, Object arg)

    MethodUtils.invokeMethod(bean, methodName, parameter);

   BeanUtils.getIndexedProperty(orderBean,"items",1);

  BeanUtils.getIndexedProperty(orderBean,"items[1]");

  BeanUtils.getMappedProperty(orderBean, "items","111");//key-value goods_no=111 

  BeanUtils.getMappedProperty(orderBean, "items(111)") 

     public static Class getPropertyType(Object bean, String name)

    我上的学校还算可以，虽然不是北大清华这样第一流名牌大学，但至少也算中国的第二流名牌大学了。大学中前面三年都陪伴着游戏过去，所学到的只是些计算机基 础知识。到大四后我突然发现就业的问题就在眼前，而自己似乎什么也不会，于是开始看书。最一开始重点看的是C++，可是后来自从看了一本J2ME的书以后 被Java所吸引。当时虽然学校上过Java课程，但是自己也只是学了很少的皮毛，也就只会写写Hello World和什么加减法之类很简单的程序，连API都知道没有几个，比如说字符串长度的API我都不知道。所以刚开始自己学J2ME的时候屡屡受挫，自己 也明白自己的缺点，决定从J2SE开始好好补上。

    刚开始为了熟悉Java开发环境，买了本JBuilder开发的教程，并且在自己的本本上安装了JBuilder进行演练。当时的我连JavaDoc都不 知道，每次究竟什么API能做什么事情一点头绪都没有，还不知道哪里去查，后来同学告诉我有个JavaDoc这个东西，我还兴奋不已，觉得自己被从黑暗中 拉回来了。一开始使用JBuilder的时候，马上为之所吸引，有两个原因，第一是因为它自动标出语法错误，边写代码边提示你什么地方语法出错，记得以前 使用VC++的时候，每次程序写好后先编译，然后再Build，再运行，这其中每个步骤都会出不少错误。特别是在编译的时候，写个200多行的程序一次编 译下来就有100多个错误，结果每次花在这上面的工夫都要好长时间。而JBuilder使用了即时语法分析，所以基本上程序写完，就可以省略调试语法错误 的步骤了。第二个原因是可以自动提示代码，这个功能可以让你迅速熟悉API，免得每次去查帮助文档那么麻烦，我就是这么很快掌握了许多API的。

可能大家会问我为什么一开始不学习《Java编程思想》，的确这本书我们宿舍就有好几本，不过大家普遍反映效果不好，到最后都不知道说的是什么，所以我也没敢看。

    经过20天左右的学习，对Java有了更进一步的了解，熟悉了不少API函数，由于在那本书上写开发SWING占了不少篇幅，所以也对Swing的开发了 解了不少。看完以后因为同学说Java的灵魂就是多线程编程，所以开始看Oreilly的《Java线程》。记得在大学中操作系统这门课我们就提到过线程 的知识。并且课本上就是用Java实现的，当时有了一点点概念，但这次看这本专门说线程的书后才发现我原来了解的那些根本是什么都不算（当然，现在回想起 来，我那时看书学到的也只是很简单的皮毛而已）。看完这本书后我自己学会在我的JBuilder下开发很简单的多线程程序，并且模拟线程冲突，等待等情 况。当时看着自己写的一两百行程序可以顺利执行，那种兴奋劲就别提了。这本书我看得也很快，大概就花了3个星期看完。

    经过上面的学习，自己相比以前来说提升了不少，这时候自己也找到了工作，是做J2EE对日外包的，所以更加坚定了努力学习Java的信心。

    在上面写的程序中，我自己写程序没有规范性，在代码编写的时候自己的盲点特别多，还容易犯低级失误。同学有一个《Effective Java》中文版，可是我看了几页发现自己根本看不懂，里面什么静态工厂啊，什么单例模式什么的根本不知道什么东东。我知道自己目前的水平还不够，所以决 定放下这本书，去寻找别的适合我的书看。这个时候我看到了候捷先生翻译的《Practical Java》一书，当时是刚刚上的书架。这本书我在书店翻了下目录后就感觉如获至宝，马上买回家，在回家的公车上就贪婪地读起来。这本书不算很厚，但是自己 看得却很认真很仔细，也明白了不少东西，比如Java中等号和equals()方法的区别，究竟什么时候用什么。还有Exception处理机制，以前不 知道什么叫Exception，只是JBuilder提示我要我抛出Exception我再抛出Exception，自己觉得这东西基本没什么用呢。但是 看了这本书后我改变了看法，我发现Exception是个很好的东西，可以迅速把程序从正常状态和异常状态区分开来，即使而准确地在指定位置得到处理。那 时自己也有了以后写程序的时候注意编写异常处理部分的想法。《Practical Java》这本书虽然不厚，但是我却非常仔细地去看了，大概花了1个月时间，我把这本书完全消化了下去。

    当时听说Java在网络上的应用非常广，我也不知道究竟是什么应用，我于是买了Oreilly的《Java网络编程》这本书。这本书虽然很厚，其实前半部 分内容不是很复杂，后半部分写什么RMI的东西我也看不大懂，只能理解个概念。通过这本书，我了解了HTTP协议究竟是什么一个东西，在它上面利用 Java传输数据该如何做，知道了什么是Request，什么是Response。这也为以后开始我的J2EE之旅打下了很好的基础。当时自己依然是边看 书边自己写代码来验证，自己写了个服务器端Socket和客户端Socket，成功进行了通信，又在上面加上了安全Socket内容，实现了SSL通信。 当时我把写的这个又套上了Swing的外壳，还和同学拿这个传文件呢。不过当时也没有考虑过什么校验码之类的东西，所以传传小文件还是可以的，文件稍微一 大一点，传过去的文件总是不对头，和我原来的文件经常会出一些差异，导致文件打不开。

    《Java网络编程》这本书看了不少时间，因为书比较厚，东西也比较多，不过除了后面的一些知识以外，其他的还是容易理解的。大概花了2个月左右的时间看 完。看完后，时间也到了2004年的3月。我也轮到开始我毕业设计的时候了。我们的毕业设计导师都还不错，给你自己选个课题，我选的是一个B/S结构的在 线简历处理系统，正好和我所学和下面所工作的东西是一条路上的了。这时我觉得我应该往B/S结构上转了，当时在选择先看Servlet还是先看JSP上犹 豫不决。最终决定先看Servlet，后来也证明了我的决定是对的，我在熟悉了Servlet后再学JSP是非常容易的，基本上根本没有遇到什么难点。

可 能有人会觉得我看了好多Oreilly的书，虽然我不能说Oreilly本本都是好书，不过相对来说，好书的概率总超过许多其他的出版社，而且体系比较齐 全。我看得几本书我都觉得还不错。现说说下面这本我学Servlet时候看的《Java Servlet编程》来说吧，很不错的一本书，让我迅速知道了什么是Servlet，然后通过最简单的实例，让你知道了Servlet如何运行的，跟 HTTP协议是如何配合的，如何返回HTML形式的文本，XML配置符该如何写，究竟每个元素是什么意思等等。由于我原来有一定的XML基础（知道XML 语法各种格式的含义而已），所以掌握起来还算比较快。通过这本书，我知道了如何动态生成HTML文档，知道如何把一个Servlet映射到一个虚拟的地 址。在后半部分写到了数据库操作部分，我对数据库的了解其实也仅限于原来大学课本上的《数据库系统原理》，如何从程序和数据库交互是一窍不通。通过数据库 操作这章，我知道了如何使用JDBC语句如何编写，大家不要笑，对于当初一个新手来说，这个真是一个全新的领域，做什么事情都需要Sample来对照，跟 着依葫芦画瓢吧，其实现在的软件开发也是这样，我想现在大家谁能直接手写Struts或者Hibernate的配置文件都很难吧。闲话少说，大概这个时 候，我对毕业设计的雏形有了点思想上的概念。看完了《Java Servlet编程》后紧接着就又看Oreilly的《JSP设计》，由于有了Servlet的基础，学起JSP特别快。当时没有着重看Tag的自定义设 计，光看了JSP的其他东西，终于在五一节后把毕业设计都写完了，当时总代码量是2000多行，第一次写这么多代码的程序觉得很有成就感。现在看起来那时 做的是标准垃圾，但是当时觉得还是很不错。用了Servlet + JSP。其实Servlet也不是用来当控制器的，而是和JSP做的差不多功能，都是作view的功能的。很快，毕业设计交差过去了，写写毕业论文，准备 答辩。在这个过程中，我又一次考虑自己下面该看什么书。

这次我又看中了侯捷翻译的一本巨著，也就是鼎鼎大名的Martin Fowler写的《重构——改善既有代码的设计》这本书。刚开始听见重构这个名字，总觉得非常高深，加上都评论说重构是和设计模式齐名的东东，感觉更加高 深恐怖了。大概在6月初我开始看了重构，刚开始看的时候虽然抱着试试看的心态，不过还是非常认真的。但是，让我颇感意外的是重构并不是很难，至少这本书中 说的非常通俗易懂，通过大量的实例让你觉得重构是种很简单很基本的技术。虽然我看完了重构以后在真实的代码编写中很少直接按照上面代码所说的方法进行重构 代码，基本上都是通过IDE来重构代码，但是却大大提升了自己编程思维，从此以后写代码就很少瞻前顾后了，因为我拥有了重构这个工具。这本书有点厚，再加 上中间有答辩，拍毕业照，以及毕业手续等等，这本书我花了一个半月看完。我看书的速度也不算快，不过我看书比较有恒心，不像有部分人看几天就不想看了，我 能坚持天天看，所以总的来说还是不慢的。我计算过，如果我每天看10页书，坚持下去，那一年就是3650页书，平均一本书365页来算，1年就是10本。 如果这10本书中有8本不属于垃圾书籍，那么你这年就能有非常大的提高了。

看重构这本书中间我也抽了一段时间看了两本其他的书，第一本是 《Java夜未眠》，挺不错的一本书，虽然是散文，但是还是能让你明白不少道理，受益匪浅。另外一本就是李维的《Borland传奇》，由于自己当时最喜 欢用的工具就是JBuilder，所以也对Borland公司非常敬仰，特别对安德森，简直就顶礼膜拜啊，哈哈。这本书写得很精彩，写了Borland公 司二十年来的血泪史，写了如何跟微软斗争，如何在微软和IBM的夹缝中生存。当然，也有很多的对于技术方面作者李维自己的见解，看了会有不少同感的。就这 样，磨磨蹭蹭地把重构看完了。

    当看完了《重构》这本书之后，我也开始去公司报到上班了。可以看出来，我当时工作的时候水平也很有限，但总比一年前要好不少，至少很多东西都已经知道了。 那时外面极限编程听的比较多，自己也去书店买了本《Java极限编程》回来看，现在想想算是我看得第一本垃圾书籍了。不过也是有收获的，这本书极限编程也 就说了点概念，然后就写了不少工具的使用方法。在看《重构》中对JUnit有了点认识，不过只是皮毛中的皮毛。看了这本《Java极限编程》后对 JUnit的使用又了解了不少皮毛，对于Cactus有了点了解，对Ant了解了不少，至少可以自己写出自己需要的配置文件了，并且可以结合JUnit生 成测试Report。由于我去的是日企，做对日外包的，所以公司开始培训日本语，用的是《标准日本语》这套教材。我于是边学日语边看技术，大概2个星期左 右我把那本《Java极限编程》初步看完后就扔在了家里。这时的我已经开始会用Ant了，觉得是步入J2EE的重要一步。

    很快啃掉那本垃圾书以后又看了本和Java不是非常有关的书：《程序员修炼之道——从小工到专家》，原因其实很简单，大学同学都说这本书是经典书，看书这 东西，别人的评价还是能起不少作用的。这本书字数不是很多，不过排版的时候比较分散，导致书本有点厚，呵呵，可能也算出版社赚钱的一种方法吧。不过总的来 说，我觉得出版社纸张质量最好的是电子工业出版社，其次是中国电力出版社，最烂的恐怕就是机械工业出版社了，机械工业出版社有少量书纸张还能说过去，但有 不少简直让人不得不有脾气啊，纸张薄得感觉和写毛笔字的宣纸都差不多了。这本电子工业出版社的书纸张质量的确不错，不过也许是因为我功力尚浅，所以这本书 虽然都看懂了，但是深有感触并且铭记于心的没有几个，现在再回想，也只记得软件模块设计时要正交等等少数几点了。这本书由于内容不是非常多，所以我就看了 半个月不到搞定。这时的我开发IDE已经转移到了Eclipse上，毕竟商业开发用D版有点说不过去，而且公司也怕查，所以不允许用JBuilder，鼓 励大家用Eclipse。我用了一段时间的Eclipse后，从一开始的不适应到后来觉得Eclipse很方便使用，JBuilder比Eclipse多 的就是一些根据不同类型开发的模版而已，而这些可以由Eclipse的插件来弥补。到了这时，我觉得我的Java基础应该算还可以的了，API也熟悉了非 常多。我觉得看《Effective Java》的时机成熟了。

    由于大学已经毕业了，所以也不会有同学的《Effective Java》放在边上让我看这样的好事出现，老老实实地去了书店买了本《Effective Java》中文版回来研读。呵呵，大家也许会问我为什么不买本E文的看，虽然我大学早早也把英语4级过了，而且大学中不少计算机专业课程教材也是E文的， 当时为了考试也认真读了。但是毕竟英语不是我们的母语，看起来速度上明显比中文版的慢一截。当然，如果是那种垃圾翻译者用机器翻译出来的中文版，看那些垃 圾中文版速度肯定比不上直接看英文原版的。这时的我看《Effective Java》已经不再是当初的那么感觉很陌生了，觉得上面说的那些要点自己想想还都是可以理解的。我个人觉得提高自身编程习惯以及水平最多的还是看类似于 《Practical Java》和《Effective Java》的这种按照条目来进行说明的书，能把你自己平时容易忽略的地方按照重点一个个揪出来进行修正。比如《Effective Java》中的第一条，使用静态工厂来代替构造函数，自己原来在进行开发的时候，从来不怎么会主动想到建立一个静态工厂，总觉得使用构造函数来新建一个对 象是天经地义的事情。但看完这个条目后，我的看法也随之改变，发现静态工厂还是非常好的，当然，也不是什么地方用静态工厂都很好。上面也写到了静态工厂的 优缺点，比如在什么地方适合使用，什么场合最好不要使用等等。这本书我觉得翻译的也不错，绝对值，强烈向有一定开发经验的人推荐。我大概看了3周半的样子 把这本书看完，这时的时间也到了2004年的9月初，新员工入司培训也不再是第一个月纯粹的日语培训，而是技术培训和日语培训一起开展，技术上培训 Java，Web开发，数据库开发这三门课程，日语则开始进行日本语国际三级的培训。公司的日语培训和技术培训都还不错，技术培训纯粹把大家当作什么都不 懂的人，在Java上从最原始的Hello World开始培训，Web开发上从HTML页面开始培训，数据库开发则从Oracle的安装，SQL语句的编写开始培训。当然，在培训的过程中我也不会 闲着，而是又开始寻找自己要啃的书本，这次，我选中了Oreilly新出版不久的《Java与XML》第二版。

    由于XML表达数据的自由性以及强大型，所以XML特别适合于做配置文件以及数据信息文件，在Java中XML的使用可谓是多如牛毛。在J2EE中，从 Web Application的web.xml开始就是XML文件，到下面的Framework配置等等，没有一个没有XML的身影，而且XML都起到了举足轻 重的作用。虽然我原来也懂一点XML，不过也仅限于XML的语法以及结构等等，那些深入下去的东西基本还是盲点，关于Java中如何处理XML更是一窍不 通。为了更好的学习J2EE，XML是必须征服得一座山峰。这次，我依然又再一次信任了Oreilly出版社，买了本当时出版不久的《Java与XML》 中文第二版。这本书刚开始并没有过多介绍XML本身过多的东西，只是为了怕某些读者并不了解XML而对XML语法结构等做了非常简要的介绍，不过也非常到 位的介绍。介绍完了这些XML基础知识后就开始了SAX——〉DOM——〉JDOM——〉JAXP——〉Web Service的历程。不过我现在觉得如果能介绍DOM4J就更好了，因为我现在觉得DOM4J是Java中最好用而且性能也不错的XML处理工具。刚开 始的我其实什么是SAX，什么是DOM都不知道，对JAXP更是一无所知。这本书英文版据说很受好评，中文版我只能说一般，因为有些地方估计译者并不擅长 这一块，所以翻译得很生硬，以至于部分段落难于理解。总体来说，书的绝大多数内容还是可以看懂，由于没有具体实际操作的经验，所以很多也就是把概念理解 了，直到几个月后做正式项目开始应用这些XML处理工具进行开发的时候才达到了熟练运用的能力。在这本书中学会了JDOM的使用方法，JDOM也还是比较 好用的，学会了JDOM，以后操纵XML也方便了许多。这本书我的建议就是，可以一口气读到第十章JAXP部分，后面的Cocoon以及SOAP等等部分 那本书介绍的并不是很好。Cocoon我是看了官方专门的帮助文档以后才感觉入了门。而SOAP是经过别的书籍加上项目中的实际运用才真正学会的。

这 时到我刚进公司已经两个月过去了，时间已经到了9月中旬的样子，还有一个月我们公司新员工入司培训就要结束，也意味着还有一个多月我们就要开始接触正式项 目。这时的我写B/S程序仅仅是JSP + JavaBean的水平，连JSP中的TAG都不会自定义，看见别人网上的程序自己还自己定义Tag很是羡慕，于是决定把那本《JSP设计》认真看完，把 自定义Tag的功能实现。后来看了以后发现原来那本《JSP设计》的精华都在最后的150页内，最后那部分先是介绍了自定义Tag的定义方法以及Tag定 义所带来的一些好处。自从学会了如何自定义Tag，在后来公司的项目中自己也根据项目的特点定义了一些共通的Tag，大大方便了不少项目中的开发人员，提 高了生产力。这本书而且也说了一下B/S开发的两种Web Module。在这里，我第一次知道了Web开发可以用一个Servlet作为控制器，用JSP仅仅作用于表现层，这也为以后掌握MVC打下了很好的基 础。

9月中下旬扫完了《JSP设计》的尾巴后，有一次跟公司给我们培训的老师在闲聊时谈到了项目开发，我询问他项目是不是用JSP和 JavaBean来开发，他笑着和我说不是这样的，而是基于Framework来进行开发。比如Struts就是公司的常用Framework。 Struts这东西以前也好像听说过，不过从来也只是听说而已，并没有看过。得到这个信息的我，为了能尽快熟悉实际项目的开发环境，便决心尽快学会 Struts。当时的市场上讲解Struts的书只有一本，也就是Oreilly的《Jakarta Struts编程》，不像现在连《Struts in Action》的中文版也有了。我去了书店买来开始回家看，刚开始看的时候觉得如同云里雾里一般，因为这本书归纳总结性的东西很多，比较适合当参考手册， 而真正带领新手入门这一块做的并不好。所以当我把这本书都看完了以后，还是不会用Struts编写一个程序，只是感觉自己朦朦胧胧懂了一些概念，比如 MVC什么的。在公司我们的培训也结束了，通知在国庆节过来以后的第一个星期——大概是10月10日左右进行考试，最后根据培训考核情况来调整薪水。当时 跟我一起培训的新员工基本上没有人会Struts，其实这个时候连会用JSP + JavaBean写一个最简单的登录画面的人也没有多少个，大部分人还是模模糊糊懂一点，但是具体做东西还是做不来的那种水平。国庆节大概10月5号的我 去了趟书店，突然发现书架上新上了一本书，就是孙卫琴编写的《精通Struts》这本书。孙卫琴的书我倒是听说过，就是在这之前出的一本关于Tomcat 以及Web App开发的书，据说挺容易上手的。我翻看了这本书的目录结构，觉得可以值得一读，于是虽然价格不菲，仍然买回家当天就研读起来。凭我的读后感觉来说，这 本书也许学术价值并不高，说得深入的东西基本没有，但是特别适合初学者，通过Hello World这种例子迅速让你手把手编写出第一个Struts程序。就这样，在这本书买回来的第二天，我自己就用Struts写了一个很简单的登录画面程 序，当时的感觉别提多兴奋了，就感觉自己入了门，以后的道路一片光明。在这里，我要由衷地感谢孙卫琴女士，写了这么一本适合初学者的书，同时也建议没有学 过Struts但又想掌握Struts的Java程序员们买这本书回来看（不知道我是不是有书托之嫌，我只是说我自己的心里想法）。

    国庆的假期放完了，我也回到了公司准备考核，上午是笔试，下午是上机考试。笔试分为了4块，分别是Java，Web开发，Oracle数据库，以及 CMMI规约。这四门除了Oracle数据库我一向不是很擅长，只考了个中等分数以外，其他三门分数都名列前茅。不过CMMI规约老实说我也不怎么会，不 过碰巧考的很多都是我知道的东西。下午是上机考试，题目给出来了，我一看题目，原来是一个最简易的成绩查询系统，也就是数据库里面已经有一些学生成绩，我 们写一个检索页面，可以输入或者选择检索条件，把符合我们检索条件的数据输出并显示在画面中。我于是拿刚学会不久的Struts进行编写，在3个小时内把 整个页面都写好了，并且还自定义了一个Tag来显示数据信息。考完以后我才知道总共也就五六个人程序可以运行，而且只有我一个人用的是Struts，其他 人基本都是最简单的JSP + JavaBean，有的人连JavaBean都没有，数据库操作全部写在了JSP页面中。毫无疑问，这次上机考试我得到了好评，给了最高分。在全部的培训 成绩中我也居前两名，我们部门新员工我排第一名。带着这个成绩，我们的入司培训基本结束，开始进入部门做实习项目。

    虽然说我们正式进了部门，不过试用期还没有结束，我们试用期最后一个月的任务就是做一个实习项目，当然，每天还是要进行日语培训，因为要参加12月份的国 际日语三级考试。公司也象征性得给大家培训了三节课的技术，第一节是Struts培训，第二节是Web App的MVC结构的培训，第三节是Log4j培训，这几次培训下来，大部分人感觉好象云里雾里一样，基本什么都没听懂，不过我由于有了点Struts的 基本知识，所以感觉收获比较大，特别是MVC的培训中我真正明白了视图——控制器——模型这三层每层应该怎么处理，知道了一个Web App中如何分Java Package比较好，明白了专门有一个DAO层来处理数据库所带来的便捷，明白了Log在Web开发中的重要地位，这为以后的开发带来了很大的好处。实 习项目的课题很快就下来了，要我们做一个电子相册的B/S系统，要求有图片上传，图片检索，图片显示以及要用Struts来构建，这些是基本的要求，其他 功能可以自由扩张。我们部门的新员工分为两个小Group，都是一样的课题，互相促进和学习，每个Group还配备了一个老员工，作为督促我们的进度，防 止我们有过大的偏差等等，不过具体做东西上原则上要求是不会给我们什么帮助。首先每个小Group要选出一个Leader，结果我被大家一致选为我们 Group的Leader。在小组讨论中我们先进行需求分析，大家的讨论很是热烈，主意也很多，不过基本上组员们也都是点子多，具体实现上面还都没有想 过。对于他们的那些建议，绝大多数我决定都作为我们要实现的目标，但也有少部分我觉得目前以我们的水平还无法实现的，就先否决了。会议开完后，当天回家以 后我就开始排开发计划和个人的进度，第二天写画面的基本设计，第三天把组员拉过来开始Review基本设计，我们组的速度还算比较快。从星期二公布课题， 到星期五就和几个组员一起把DEMO画面设计出来了。原来的计划是第二个星期一开始Coding，大概花一个星期完成。不过其余组员似乎还是不怎么会 Struts，于是我回家星期六星期天基本全天都在看书写代码学习，花了两天把项目基本Coding完毕。其中Web页面部分也不再使用一开始使用 Frame的做法，而是采用了Tiles框架。Tiles的使用过后我感觉是非常好的东西，经过简单的配置可以完成大批网页中类似部分的构建，而且生成的 属于一个页面，这样就省去了以前写Frame时提交页面总是要考虑设置Target以及在引用对象的时候大批Parent或者top对象使用的麻烦事了。 在开发过程中我使用了Log4j，这为我的调试程序带来了极大的方便，呵呵，可以想象，没有Log来调试一个Web程序真是不可想象的。

这 段时间我是边开发边翻查那本《精通Struts》的，这样，迅速把Struts中提供的许多Tag弄熟练了，为以后具体的项目开发带来了便捷。也许是一向 以来公司的实习项目完成效果都不是很理想吧，这次我们的迅速完成比较出乎Leader的意料，综合三个月的试用培训，由于我在日语和技术以及实习项目中表 现都还不错，所以定工资级别时也是同一批进公司的新员工中最高的，随着转正会议的结束，我也在10月底成为了公司的正式员工。大概刚刚进入11月份，我们 Group便开动一个项目，项目不是很大。当时老员工们许多都在做项目的详细设计，我便跟着公司一位技术专家（也是当初给我们入司培训的其中一位老师）做 起项目的Framework构建工作。当时的我才进公司，第一资历尚浅，第二我的确也并不是很会什么东西，所以给我的任务很多都是一些模块的 Utility的设计。比如通用的Check方法啊，CSV以及定长文件的读取解析什么的啊，还有某些在IE中可以实现的效果如何在Netscape中也 能实现同样的效果等等。虽然这些东西在现在看来并不是很复杂，但是当时自己的确随着做这些东西而学到了很多很多。比如使用JDOM对XML文件的解析啊， 很多Check方法的小技巧啊，IE和Netscape究竟有什么地方不一致，该如何解决等等，这些都在这几天内了解了很多。在这几天中，我通过网上查找 资料，临场迅速学习了Java反射的使用方法，并且自己边学边写实例，实现了各种情况下的反射案例。我个人觉得掌握Java反射技术是非常重要的，这让你 可以写一些通用的工具。如果不会反射技术的话，也许你永远只能写一些针对特定情况下的解决方法。而会使用反射以后，你可以写一些代码，这些代码可以用在许 多地方，达到自己扩展甚至构建Framework的效果。在这个项目中，我使用了自定义Tag和Java反射技术，定义了些项目中比较需要的通用的 Tag，方便了大家。

    后来听老员工说新员工进公司就开始做Framework是以前从来都没有过的事情，因为我们Leader对我希望比较大，所以想尽可能培养我，让我早点挑 起项目大梁，所以给我的成长提供了一次又一次的机遇。11月中旬以后，项目开始进入编码阶段，我也第一次看到了正式的项目设计书。第一次看到设计书的时候 我都觉得自己脑子有点懵，一大堆日语什么含义自己不是很清楚，而且感觉根本无从下手，不知道从哪里开始看比较好。项目担当耐心得和我说了设计书的格式以及 究竟什么地方是什么一个含义，以及Coding的时候按照什么个思路来看设计书。再加上项目中有老员工先写了个Sample，让大家看了标准的一个流程， 所以我们就依葫芦画瓢，慢慢得把一个画面一个画面Coding完毕。当然了，后来也有测试员来测试我们的画面，发现bug后就发Bug Report给我，那一个月就是在Coding，修正Bug中渡过的，这个项目是用Struts做的，因为不大。所以也没有再用其他的 Framework，数据库操作那里只有个非常简单的单表操作DAO层，其余的DB操作都是自己通过JDBC操作语句来完成的。在这第一个自己接触的真正 项目中，我自己学到了很多B/S设计的技巧，感觉很充实。不过书本学习方面我也没有闲着，我为了能够深入了解Java，大概在11月中旬左右开始看《深入 Java虚拟机》这本书，由于内容比较深入，所以看得也有点吃力。书翻译得和写得都还不错，值得一看，我一直看了前八章，看到Java程序运行细节后就没 再看了，大概看到了12月底的样子吧，呵呵，有时间的话决定把后面的部分也看完。这本书看完后收获就是了解了Class文件的实质，Java的安全模型， 虚拟机是如何工作的。这些知识对后来调试程序Bug或者Exception的时候非常有好处，可以把以前自己觉得莫名其妙的错误的原因找出来，不像以前遇 到很古怪的Exception的时候怎么死的都不知道，从读完这本书以后，在以后的调试异常中很少再有不知所以然的感觉了。

    2004年12月底的时候，我的第一个项目也做完了，由于我空闲着，Leader便在星期三的时候把一个公司内部开发的Source统计的小工具让我进行 修改，使得添加一个比较有用的功能。东西给我的时候基本没有任何文档，在我手上的就是一堆源代码而已，界面是用Swing制作的，因为没有专门在UI上进 行精心设计，所以说不上好看，典型的Java编写的图形界面的程序的样子。软件不是非常大，估计在1万行源代码以内，不过对于只有一个人修改来说，也比较 够呛了。还好我在刚学Java的时候用JBuilder写了一些Swing的程序，现在还是对Swing有概念的，所以拿到手上以后经过仔细分析，逐渐理 清了头绪。经过修改和自己测试完毕后，觉得还比较满意，达到了预期的目标，于是在星期五的时候提交给了Leader。通过这次，对Swing的开发又加深 了印象，自然，在有的细节技巧方面受益匪浅。

元旦很快来临了，在年底以前，公司觉得有必要学习下Hibernate，虽然我们目前的项目中 还没有用过Hibernate，而是用另外一个公司内部开发的ORM工具，不过几名技术专家初步对Hibernate感觉后觉得Hibernate的功能 要强大的多，而且是开源的，不断有人在推动，升级，所以有必要我们要学Hibernate。这次的学习采用学习小组的形式，也就是公司内部先抽几名员工 （主要是技术部门的，当然，开发部门如果有兴趣的话也可以考虑）来进行深入学习，然后定期开会交流互相学习，达到短时间内先行的几名成员迅速深入掌握 Hibernate的形式。由于我第一处于空闲状态，第二也比较有兴趣，而且跟技术部门的专家们也比较谈得来，所以我也加入了其中，成为几名学习小组中成 员的一部分。我们学习资料主要就是《Hibernate in Action》英文版一书以及官方的帮助手册。我负责其中对象操作，Transaction和Cache，还有高级Mapping关系的设置几个部分的学 习。由于资料都是全英文的，所以看书速度并不是很快，不过还是初步得到掌握了。大概学习了半个多月的样子，我们各自基本学习完毕，互相交流后并且写下了读 书笔记，用来后面具体项目开发时候参考用。通过这大半个月的学习，我个人觉得提高了非常多，在这之前，我只知道有ORM这种东西，但是从来没有使用过，也 从来没有看过。自从学过了以后，我不仅对Hibernate在代码编写时的使用比较熟悉了，而且对Hibernate的配置以及许多底层的知识有了很清楚 的认识，让自己在数据持久化方面的认识提高了大大的一步。

    元旦过后，虽然一边在学习Hibernate，不过由于下面项目的需要，Leader跟我说要我学一下Unix下的Shell编程，因为 项目中许多批处理会用Shell来启动。UNIX命令在学校时候学过的，不过这个时候已经忘记了很多，只是翻阅资料的时候还能回想起来不少命令。 Shell并不难，如果有了编程基础，学习Shell编程也很快的，总体感觉就是编程语言大同小异，从基本语法来说，不外乎赋值、条件、循环这几种类型。 只要迅速掌握这几种类型在这种编程语言中的编码格式，那么你就可以迅速掌握这门语言最基本的编程能力。Shell经过一周的学习后觉得感觉不错，不仅可以 顺利看懂别人写的Shell程序，而且自己可以在Linux下顺利写出符合自己需求的Shell程序并能顺利执行。但是突发事件总是有的，那个项目突然决 定延后两个月，所以前一个星期的学得Shell等于暂时派不上用场了。不过嘛，多学一样技能总是没有害处的，而且又复习了那么多Unix命令啦，感觉还是 很不错的。于是我又进入了不在项目中的真空期了。

    但是好景不长啊，好日子还没有过上两个星期，公司去年做的一个比较大的项目开始了2期开发，我也被一下拖入了项目中。说起那个项目，公司好多人还心有余 悸，据说去年那个项目开发的时候，大概50多号人干了好几个月，每天都是11点以后才有可能回家，周六是铁定加班，周日是看情况，晚上就算加班加到凌晨3 点也不是什么奇怪的事情。当时大家都说多来几个这种项目大家就要死了，这次这个项目的2期过来了，大家精神又一次紧张起来咯。一开始照例是项目会议，听完 项目经理描述以后，大家也放心了不少，这次虽然说是二期，不过规模不大，只需要15个人左右干一个月就能搞定。主要是把项目一期里面一些地方进行改修，当 然也有需要新的画面的开发，不过相对于去年的那块不是很多而已。对我来说这次是个很大的考验，因为项目是二期，项目组内除了我，其他的人都做过1期开发， 所以对项目结构都很清楚。这次项目开始并没有什么培训，所以我只能单独看1期的源代码来熟悉项目结构什么的。这个时候项目经理把我叫去要我办理护照，准备 这个项目派遣我去东京现场维护。

这个项目是个比较全面比较大的项目，服务器采取了集群的方式，数据量也是千万乃至上亿级别的，所以性能要求 特别高。在技术方面用到了很多，使用EJB来控制Transaction，使用了ORM工具来操纵DB数据等等等等。而且由于比较庞大，所以服务器初始化 的那块为了Load上去大批配置信息，代码量极其庞大，在权限控制的那块地方，代码非常难以读懂。这也给我一开始的学习代码带来了很大的一块麻烦。不过总 算静下心来后把整个项目框架以及实现手法基本摸清楚了，这个时候觉得非常开心，而且对Web应用程序的构造心里面也非常充实，觉得自己已经具备写 Framework的初步能力了。

项目是紧张的，基本上每天晚上都要加班到11点，然后打车回家，哈哈，公司报销。而且临近过年，这么加班 也一点都感觉不到过年的气息。不过我也不能因此放松了自己的学习。我觉得自己的基础应该算比较好了，便开始啃起另外一本大部头——《Java与模式》。一 直以来我对设计模式的感觉就是一些已经成型的，久经考验的代码框架，具有非常好的可扩展能力以及非常好的代码健壮性。不过初学者最好不要看设计模式，因为 你接触的代码不多，如果贸然看设计模式的话，会造成不明白为什么这种设计模式好，究竟好在什么地方的情况下就在代码中乱套设计模式，对自己的以后编码发展 带来不利的影响。每一种设计模式都有每一种设计模式的特点，自然也有他们自身的适用范围，比如拿最基本的单例模式（Singleton）来说，适合于做配 置信息读取器，主键产生器等全局唯一的东西。如果初学者不明白这些，拿单例模式乱套，什么都用单例模式，比如把普通传递数据用的JavaBean也做成了 单例模式，带来的恶果就严重了。这本《Java与模式》我是从头到尾认认真真看了，每看完一个模式都会仔细回想以前看的代码哪里用到过这个模式，总会自己 想想这些模式适用于哪些地方。因为这个时候我自己编写的代码行数也已经很多了，所以看见这些模式就会特别有感觉。经过50多天的认真研读，所有模式都被我 消化了下去，并且使得我的对程序开发上面的认识提升了非常大的一步。顺路说一句，这本书写得非常好，例子很多，但是不复杂，有一定代码编写经验的人就可以 看懂了。不过看懂并不是最重要的，重要的是消化下去，用来理解以前看过的代码的精华，这样自己才能得到提高。

    这个项目虽然很紧张很忙，不过我还是适应了下来，而且对整个项目结构什么的都有了比较好的整体的把握。项目横跨了整个过年期间，所以在过年的那几天都必须 开着手机，怕有什么突发事件要求去加班。签证在2月4日左右送过去签，Leader跟我说因为在过年期间，所以签证可能会比较缓慢，比较难签，不过一般情 况下1个月应该足够了。原计划我是跟另外两个同事3月6日去东京，这样算算也差不多。不过中国有句话叫好事多磨，呵呵，用在我身上的确不过分，我的签证3 月3日日本领事馆才签，三月四日送到南京。3月5日和3月6日是双休日，所以3月7日签证才送到我手上。由于计划是3月6日派人去东京，所以只好派另外一 个身上有签证还没有过期的人代替我过去，这次的机会就算泡汤咯。不过我并不是很在意，因为公司这里去东京出差的机会狠多，特别对于开发人员，据说工作几年 后一听到去日本出差就不乐意，毕竟也背井离乡么。

    在这个项目的途中，大概在2005年1月底2月初的时候公司也开始进行了制作详细设计的培训，我虽然在项目中，不过也成为了其中一员。这次培训总共大概6 次课，每次2个多小时，虽然时间不长，不过把详细设计的要点以及思路和容易出错的地方都说了出来，感觉很是不错，这几次课的培训后，虽然可能要我立即进行 详细设计编写还有点困难，不过心里面已经有了不少底，我觉得经过一段时间后的锻炼，我应该可以有进行详细设计的能力了。

    3月初这个大项目结束后，本以为可以休整下，不过很快通知我3月7日加入另外一个项目，其实也不算一个正式的项目，属于公司知识库的一个信息查询模块。由 公司的一个技术专家负责，那人也就是我进公司时候第一个项目中带着我的那个技术专家，说起来我和他还真有缘，现在我这个项目还是跟着他，而且公司里面唯一 一个和我同月同日生的人，真是很巧的巧合呢。他人挺好，很热心，所以我也从他那学到了很多东西。这次由于不是正式项目，所以并没有什么基本设计书，而是他 给我们开会议的时候大致说了下项目的内容，每个画面的具体功能以及数据库表格的设计。由于这次项目规模很小，总共就12个画面的量，所以不采取 Struts等Framework，而是采用比较原始的JSP + JavaBeans的构造。我们每个人根据他所跟我们讲解得功能写每个人自己分配到的画面的详细设计，其实也不算真正的详细设计，就是每个人把自己操作的 那块的具体逻辑设计写出来，然后和他一起review一次，再开始编写代码。详细设计这里我做的很快，当天下午就把自己分配到的两个画面业务逻辑什么的都 写好了，星期一布置得任务，我星期三的时候全部编码自测完毕提交，所以我的感觉就好像这个小项目一瞬间就结束了。

日本每年财务结算是在3月 份，所以我们历来的习惯就是每年1月和2月很忙，3月开始清闲，一直可以到5月左右会接到个大项目昨。所以接下来就真正到了我的空闲时期，没有项目的压 力，我可以自由学我自己喜欢的东西。很久以前买了本《精通EJB》第二版，可是一直以来我觉得自己功力尚浅，所以没有看，这次我想认真学学EJB。虽然大 家公认EJB并不是很好，不过历来受到批评的都是EJB中的Entity Bean部分，这部分我觉得可以借助Hibernate来弥补，而会话Bean和消息驱动Bean则还是挺不错的。这次也当学一门技术，学习其好的东西， 不是很好的东西就当作以后开发时候的借鉴。《精通EJB》这本书我的感觉是书质量比较好，不过翻译的水平稍微差了点，特别是有不少错误，而且很低级的错误 居然校对的时候都没有发现，不能不说是个比较大的瑕疵。但是它不失为一本EJB的好教材。从一开始的JNDI开始，然后讲解了对象序列化，RMI- IIOP等等。这些以前都模模糊糊，或者是看过了但是还不知道究竟有什么用。但是经过这次的学习以后，对这些分布式系统比较需要的东西有了进一步的了解， 感觉头脑中比较清晰，究竟RMI是什么样的工作原理，怎样实现一个远程方法调用等等。接下来的EJB学习，自己用Eclipse + Weblogic边看书边动手，写了一个个自己的学习小程序。我个人感觉看书最好就是边看边自己动手写小学习程序，这样比光看不练能学到多得多的东西。学 了EJB后觉得脑子又清晰了很多，看见一个案例后头脑中就会有好几种如何解决的方法，几种方法互相在头脑中自己比较，经过这样，大大提高了自己的思维活跃 性。

    3月中旬开始由于公司比较清闲，大部分人处于没有项目的状态，所以公司举办了第一届全公司范围的编程竞赛。公司只指定了题目为一个日历系统，要求具有日程 记事等功能，其余功能自由发挥。这次不再采用团队形式了，而是采取各自为战的策略。自从培训过详细设计以后，我头脑一直有如何写详细设计的思路，这次我自 己首先指定了开发计划，保证自己控制自己的进度。接着进行了需求分析，确定了我有哪些功能。然后在自己的基本设计中开始进行数据库结构设计。这次我决定采 用Hibernate+Struts的结构进行编写，这样我的数据持久层操作大大简化，而且功能上也增强了许多。DB设计好以后我开始DEMO画面的制 作。说实话，我美工水平实在不怎么样，可以说虽然一般网页的效果我都会自己做出来，不过具体网页设计成什么样我还真是一窍不通。还好 Dreamweaver我还算算是比较熟练，自己捣鼓捣鼓也想摸象样把DEMO画面给设计出来了，不过美观不美观我就觉得不怎么样了，只是我能力有限，也 没办法设计的更好看，这个时候我感受到了一个项目中美工是多么重要啊。下面的详细设计自己写得很开心，把需要的功能都用文字反映了出来，这也算我写成详细 设计样子的第一份详细设计了，做完挺有成就感的。接下来首先构筑自己这个小项目的Framework，经过公司两个正式项目的洗礼后，那两个项目的 Framework我都认真研读过源代码的，所以我自己有了自己心里一套Framework的构造方法，特别是如何把Struts和Hibernate结 合起来的结构，自己有自己的一些想法。在这次Framework构造中，我没有复制任何公司以前的代码段，都是凭着自己对以前看的代码理解后写出来的。这 次项目我觉得对自己的提高也很大，首先锻炼了自己详细设计的能力。其次，自己虽然学习过Hibernate，不过从来没有这么样应用过 Hibernate，这次让自己大大提升了实践运用的经验。公司由于知道这时也没有一个真正的项目使用Hibernate，所以这时的我也算公司内部 Hibernate使用经验最丰富的人了，这也为了后来我协助别的使用了Hibernate的项目解决问题的原因。再次，我这次自己写了 Framework，特别在批处理方面，运用了许多刚学会理解掉的设计模式，这些模式让我的程序更具有健壮性和可扩展性，让我在设计方面的能力大大提升 了。

这次的编程竞赛我写得比较认真，代码量的确也很大，总代码行数超过了3万行，有效代码行数也在1万行以上。经过公司专家们的评定后，我 得到了第一名，虽然没有什么奖品，不过肯定了我这段时间以来的努力，我还是很开心的。而且这次的编程竞赛让我大大增加了编码的熟练度，而且也在其中演练了 许多自己想出来的编程技巧，为以后的发展带来很大的好处。

    从4月份开始，公司由于比较清闲，所以部门内部开始进行各种培训。我们部门开展了3项培训，第一项就是编程能力培训，第二项是Oracle数据库技术培 训，第三项是测试技巧培训。在编程能力培训中，主要就是把原来没有注意的细节采取大家讨论，轮流讲课的方式进行的，虽然其中很多东西我原来都是知道的，不 过也有原来不清楚的地方。而且经过了这次互相讨论，更加加深了印象。在Oracle培训中我觉得收获很大，这个Oracle培训采取了传统的上课的模式， 由我们开发小组中一个取得OCM的老员工给我们讲解。对于Oracle，我原来基本上就只会写写SQL语句，具体Oracle有什么特别的功能，可以做什 么我也不是很清楚。但是这次上课从Oracle的启动原理开始，让我知道Oracle中究竟有什么，Oracle数据库各部分在磁盘上是如何存放的， Control File，Redo File究竟是什么意思，在数据库中起什么作用，数据库是怎么依赖他们运行的，还有如何对Oracle进行系统管理员级别的管理，如何在不停止数据库运行 的情况下进行数据库的更新、升级、备份等等。这些东西虽然非常有用，但在平时的开发是学不到的，这次趁着这个机会大大提升了自己Oracle的水平，感觉 非常开心。数据库一向是我的弱项，在上大学的时候我SQL语句能力只是一般，数据库管理配置什么基本一点都不懂，通过这次集中的培训，我觉得自己的能力又 进一步增强了，弱项也在慢慢退却。在三项培训中最后进行的测试培训我承认我没有怎么认真去学，所以学会的也就是些测试概念，具体的测试技巧什么的还是不怎 么会。现在开发和测试的结合性越来越高，看来要下下功夫，以免给淘汰咯。

    提了这段时间在公司的进展，还没说自己的学习呢，这段时间正好看见中文版的《JUnit in Action》出版了，在书的背后写着“如果没有看过这本书，就不要对J2EE进行单元测试”这句话。我早在去年就了解了JUnit的强大功能，再加上 Ant的话对于回归测试是非常便利的。趁有时间，我便于3月底4月初的时候开始看这本书。当时的我看《精通EJB》第二版看了一半，发现其中错误越来越 多，而且文字也有些地方不知所云了，所以扔下不再浪费时间看那本书，专心攻读《JUnit In Action》。凭良心说，Manning的这套In Action丛书的确很不错，从我先前看的《Hibernate In Action》英文版就能看出来，其中对代码的编排非常方便读者，感觉可以很顺利的看到你所想看到的代码片断。这套《JUnit In Action》也是一样，博文视点的纸张还是很好的，排版使用了Manning的风格，阅读起来很舒服，所以我读得很快，大概就两个多星期就读完了这本 400多页的书。感觉的确收获不浅，首先，原来的自动化配置工具中只会使用一个Ant，其他的基本没听说过，在这本书上详细介绍了Maven。听过书中的 讲解以及自己的试验，的确觉得Maven功能很强大，不过感觉起来配置比Ant要麻烦，所以我自己的感觉是Ant在项目中还是会广泛应用，不过Maven 在大型项目，特别是整个Site中有很大的用武之地，对于我们来说，使用的方法都是很简单的，掌握如何编写配置文件才是我们的关键。

书对 JUnit与Cactus在J2EE的测试手法上给了大量的事例，给人的感觉非常好，In Action这套丛书最大的优点就在这里，用实例代码片断让你迅速了解一样东西。在实际工作中其实JUnit应用也是比较广泛的，特别如果采取测试驱动开 发的话，JUnit是必不可少的一部分。在TagLib测试，JSP单体测试，数据库测试和EJB测试都是我以前根本没有看过的东西。其实这次虽然学是学 会了，不过真正做的时候还是要有个代码例子依葫芦画瓢。我想大家肯定也都有这种感觉，写程序的时候先找一段有点相似的代码片断Copy过来，然后看看要修 改什么地方，真正从头到尾自己用手写的代码片断是不多的，除非你已经烂熟于心。不过这本书快看完的时候，项目又来了。

    这次做一个企业的MIS系统，与以往不同的是，这次客户给了一个比较庞大的基盘，封装了近100个Tag，基本上把各种各样有可能遇到的操作都封装到 Tag里面了。而且所有的画面显示等信息都是放在数据库的Table中，所以这次要求不写任何程序代码，只是学会使用好这些Tag，然后利用这些Tag写 出Jsp页面。一开始的时候还真是头疼，这些Tag一个都不明白，而且文档不是非常齐全，Tag的Source中注释也比较少，学习起来不是很方便。我们 一共3个人投入到这个项目的前期准备中，在第一个星期的学习中大家互相分配好个人学习的模块，随时互相交流。在后来的深入中发现这个项目的业务逻辑操作会 使用PL/SQL以及存储过程来进行，对于我来说，PL/SQL是从来没有做过的东西，就叫做一窍不通，于是我需要从头开始学习PL/SQL，以及如何编 写存储过程。我从网上下了一个PL/SQL的电子书籍，然后在公司花了一天时间进行学习，个人用的是Toad来调试PL/SQL的，虽然别人喜欢用 PL/SQL Developer来进行开发，不过我还是比较钟爱Toad，而且Toad的确功能也很强大，使用起来也很方便就是了。经过第一天的PL/SQL的学习， 基本掌握了全部语法以及存储过程的书写格式等等，开始能够写写非常简单的PL/SQL。接下来的两三天不断巩固熟练，客户那里也发过来几本详细设计让我们 练习着做一下。有了实际的详细设计，再加上我们之间互相交流，我们提高的都很快，大概过了三四天，大家就把基本详细设计代码编写完毕了，而且经过实际锻 炼，我的PL/SQL编写存储过程的水平也大大提升，已经可以满足开发中的需要了。

这个项目因为如果我们一开始做的能让客户满意的话，后续 的项目将会比较庞大，所以Leader决定把我们Group比较空闲的其他人也先培训一下，让他们有点感觉，到以后正式开发的时候也能迅速进入状态，负责 给他们培训的任务也就交给了我。说起来是培训，其实也就是把大概流程以及方法通过一次会议的形式告诉他们，然后把我前面已经作好的那个画面作为他们的作 业，要他们看着设计书自己把画面制作出来。这个时候也要放劳动节了，黄金周可以休息一个星期，想想就觉得很Happy。劳动节的时候基本没有怎么学习，只 是先把XML-RPC仔细看了下，学会了如何去写一个XML-RPC的应用，接着稍微看了点SOAP，看得也不错，只是些简单的SOAP的例子而已，那些 SOAP的复杂东西都没有看。

    很快就五一黄金周七天放假放完，八号开始上班，上班后就开始正式做节前就定好的那个项目，这次性质属于试做，也就是人家先发一批设计书过来，我们然后开始 Coding，大概做了一周后，我自己害了急性结膜炎，只能回家休息，这次可真的是只能休息了，眼睛觉得特别涨，不要说电脑了，连书都不能看，看了眼睛就 疼。所以在家就只能睡大觉，过了一周眼睛大概才复原，可以去公司上班了。回到公司以后，Leader通知我说我不用去做上次那个项目了，要我加入我们 Group的一个新的项目，这个项目比较大，当时还处于东京刚刚做好基本设计，我们从东京把任务接下来，准备发回来做详细设计。我进去的时候项目才开始三 四天，基本上还没有做什么，这次我进入了详细设计制作小组，开始进行这个项目的详细设计的制作。

    由于我属于第一次在正式的项目中参与详细设计，所以很多东西都不明白，特别是业务上面的东西，许多日语中的业务术语我根本不明白，比如什么卖切，切替，仕 入什么的。看着基本设计书，感觉跟以前看详细设计书有很大的不同。具体的东西写的少了，业务流程逻辑框架什么的比较多，所以需要首先把业务内容都熟悉了， 才可能写出详细设计来。这次的详细设计我也不是孤军奋战，而是有一个进公司4年的老员工带着我一起做，我的任务很轻，不过重点是学会如何去写详细设计，也 许下次再有一个比较大的项目，就没有别人再带着我，而是我自己一个人去完成详细设计了。大概详细设计写了20天左右，我被通知当天把手上的一份详细设计写 完，第二天进入方式设计小组进行方式的设计。

进入方式小组以后，接到的任务就是好几个编写DB操作方面的代码自动化生成工具。由于这次DB 方面并没有非常强制性的那种规约，所以SQL语句的编写可以说比较随意，这就给我工具的编写带来了很大的难度和挑战。这次负责管理方式小组的人仍然是进公 司以后经常带着我的那位技术专家，所以也真算很巧呢。写工具其实很对自身代码编写的提高也很有好处，因为首先客户那里资料会不断修改，这些工具你为了以后 客户更新资料后你能顺利更新工具，你需要设计一个优良的Framework，不一定需要多么复杂的Framework，不过一定要尽量把程序各方面的耦合 度尽量降低，这样才有利于自己对工具进行扩展。紧接着很快，项目代码编写开始了，我的任务算中等偏上，有2个画面和一个批处理需要编写，复杂度还算比较繁 一点。这次项目需要编写JUnit程序，每天都要进行回归测试，保证代码Method的正确性。JUnit虽然自己会用，但是从来没有在真正的项目中使 用，所以在真正用的时候感觉有点手足无措。以前做JUnit从来都是觉得给个参数，检测一个返回值就好了，其实不是那么回事，业务逻辑复杂了，自己需要做 大量的Stub来模拟真实的Class的返回值。设计一个好的Stub是比较困难的，特别在数据库内容比较丰富的时候，一张数据库Table就有上百个 域，工作量可见一斑了。项目要到05年9月中旬才会结束，所以现在还在紧张的开发阶段。我写了JUnit的感觉就是难点不在如何去写JUnit程序，而是 如何去设计测试用例。对于我们这样不是以测试出身的程序员来说，设计测试用例是很痛苦而且很艰难的事情，估计有过相似经验的人肯定会表示赞同。

    当然我一边在紧张的做项目，对于书本的学习也没有闲着。这段时间抓紧把侯捷的Word排版艺术扫了一遍，看完觉得收获颇丰。虽然我以前觉得我在Word上 用得挺不错，日常的一些操作什么的我都会，不过看这本书的中间我发现我还是有很多地方不会的，也学到了不少东西，在以后的Word排版中会很受到好处。由 于项目用到了Spring知识，所以我也看了网络上那个流传广泛的Spring开发指南的PDF看了一遍，感觉长了见识，对IOC以及DI有了进一步的了 解，也理解了为什么需要采用IOC以及DI。不过这个也没有深入下去仔细看，以后等项目稍微空闲一点的时候一定再把Hibernate和Spring好好 看一下，学习人家的设计理念，提高自己能力。对了，也许最重要的是我最近在看一本书，就是《J2EE核心模式》的第二版，我当时原来准备看电子版的这本 《Core J2EE Patterns》的，不过突然在书店发现这本书的中文版出来了，而且译者有熊节的名字，也就是跟侯捷一起翻译《重构——改善既有代码的设计》的那个译 者，我比较相信他翻译的水平，于是买回来看，虽然项目非常紧张，我一个月算上周末需要加班在100个小时左右的样子，但是我相信时间是海绵里的水，只要去 挤，肯定会有的。所以我到现在大概看了2周的样子，已经看了300多页，而且感觉自己的设计视野也开阔了许多，这本书的确很好，把J2EE中常用的一些模 块原理都说了出来，说明了为什么这么做好，这么做如何减少了耦合性，提高了可维护性等等，总之，有1年以上J2EE开发经验而且觉得自己对J2EE有了比 较好的了解的开发人员我强烈推荐看这本书。看了这本书以后我都在回想以前设计的一些框架，一些模块，觉得自己有很多地方当时设计的时候觉得很精巧，不过却 属于弄巧成拙，加大了模块的耦合性，所以在修改的时候比较难于下手。

六种异常处理的陋习

你觉得自己是一个Java专家吗？是否肯定自己已经全面掌握了Java的异常处理机制？在下面这段代码中，你能够迅速找出异常处理的六个问题吗？

　　作为一个Java程序员，你至少应该能够找出两个问题。但是，如果你不能找出全部六个问题，请继续阅读本文。

　　本文讨论的不是Java异常处理的一般性原则，因为这些原则已经被大多数人熟知。我们要做的是分析各种可称为“反例”（anti-pattern）的违背优秀编码规范的常见坏习惯，帮助读者熟悉这些典型的反面例子，从而能够在实际工作中敏锐地察觉和避免这些问题。

　　反例之一：丢弃异常

　　代码：15行-18行。

　 　这段代码捕获了异常却不作任何处理，可以算得上Java编程中的杀手。从问题出现的频繁程度和祸害程度来看，它也许可以和C/C++程序的一个恶名远播 的问题相提并论??不检查缓冲区是否已满。如果你看到了这种丢弃（而不是抛出）异常的情况，可以百分之九十九地肯定代码存在问题（在极少数情况下，这段代 码有存在的理由，但最好加上完整的注释，以免引起别人误解）。

　　这段代码的错误在于，异常（几乎）总是意味着某些事情不对劲了，或 者说至少发生了某些不寻常的事情，我们不应该对程序发出的求救信号保持沉默和无动于衷。调用一下printStackTrace算不上“处理异常”。不 错，调用printStackTrace对调试程序有帮助，但程序调试阶段结束之后，printStackTrace就不应再在异常处理模块中担负主要责 任了。

　　丢弃异常的情形非常普遍。打开JDK的ThreadDeath类的文档，可以看到下面这段说明：“特别地，虽然出现 ThreadDeath是一种‘正常的情形’，但ThreadDeath类是Error而不是Exception的子类，因为许多应用会捕获所有的 Exception然后丢弃它不再理睬。”这段话的意思是，虽然ThreadDeath代表的是一种普通的问题，但鉴于许多应用会试图捕获所有异常然后不 予以适当的处理，所以JDK把ThreadDeath定义成了Error的子类，因为Error类代表的是一般的应用不应该去捕获的严重问题。可见，丢弃 异常这一坏习惯是如此常见，它甚至已经影响到了Java本身的设计。

　　那么，应该怎样改正呢？主要有四个选择：

　　1、处理异常。针对该异常采取一些行动，例如修正问题、提醒某个人或进行其他一些处理，要根据具体的情形确定应该采取的动作。再次说明，调用printStackTrace算不上已经“处理好了异常”。

　　2、重新抛出异常。处理异常的代码在分析异常之后，认为自己不能处理它，重新抛出异常也不失为一种选择。

　　3、把该异常转换成另一种异常。大多数情况下，这是指把一个低级的异常转换成应用级的异常（其含义更容易被用户了解的异常）。

　　4、不要捕获异常。

　　结论一：既然捕获了异常，就要对它进行适当的处理。不要捕获异常之后又把它丢弃，不予理睬。

　　反例之二：不指定具体的异常

　　代码：15行。

　　许多时候人们会被这样一种“美妙的”想法吸引：用一个catch语句捕获所有的异常。最常见的情形就是使用catch(Exception ex)语句。但实际上，在绝大多数情况下，这种做法不值得提倡。为什么呢？

　 　要理解其原因，我们必须回顾一下catch语句的用途。catch语句表示我们预期会出现某种异常，而且希望能够处理该异常。异常类的作用就是告诉 Java编译器我们想要处理的是哪一种异常。由于绝大多数异常都直接或间接从java.lang.Exception派生，catch (Exception ex)就相当于说我们想要处理几乎所有的异常。

　　再来看看前面的代码例子。我们真正想要捕获的异常是什么 呢？最明显的一个是SQLException，这是JDBC操作中常见的异常。另一个可能的异常是IOException，因为它要操作 OutputStreamWriter。显然，在同一个catch块中处理这两种截然不同的异常是不合适的。如果用两个catch块分别捕获 SQLException和IOException就要好多了。这就是说，catch语句应当尽量指定具体的异常类型，而不应该指定涵盖范围太广的 Exception类。

　　另一方面，除了这两个特定的异常，还有其他许多异常也可能出现。例如，如果由于某种原因， executeQuery返回了null，该怎么办？答案是让它们继续抛出，即不必捕获也不必处理。实际上，我们不能也不应该去捕获可能出现的所有异常， 程序的其他地方还有捕获异常的机会??直至最后由JVM处理。

　　结论二：在catch语句中尽可能指定具体的异常类型，必要时使用多个catch。不要试图处理所有可能出现的异常。

　　反例之三：占用资源不释放

　　代码：3行-14行。

　　异常改变了程序正常的执行流程。这个道理虽然简单，却常常被人们忽视。如果程序用到了文件、Socket、JDBC连接之类的资源，即使遇到了异常，也要正确释放占用的资源。为此，Java提供了一个简化这类操作的关键词finally。

　　finally是样好东西：不管是否出现了异常，Finally保证在try/catch/finally块结束之前，执行清理任务的代码总是有机会执行。遗憾的是有些人却不习惯使用finally。

　　当然，编写finally块应当多加小心，特别是要注意在finally块之内抛出的异常??这是执行清理任务的最后机会，尽量不要再有难以处理的错误。

　　结论三：保证所有资源都被正确释放。充分运用finally关键词。

反例之四：不说明异常的详细信息

　　代码：3行-18行。

　　仔细观察这段代码：如果循环内部出现了异常，会发生什么事情？我们可以得到足够的信息判断循环内部出错的原因吗？不能。我们只能知道当前正在处理的类发生了某种错误，但却不能获得任何信息判断导致当前错误的原因。

　　printStackTrace的堆栈跟踪功能显示出程序运行到当前类的执行流程，但只提供了一些最基本的信息，未能说明实际导致错误的原因，同时也不易解读。

　　因此，在出现异常时，最好能够提供一些文字信息，例如当前正在执行的类、方法和其他状态信息，包括以一种更适合阅读的方式整理和组织printStackTrace提供的信息。

　　结论四：在异常处理模块中提供适量的错误原因信息，组织错误信息使其易于理解和阅读。

　　反例之五：过于庞大的try块

　　代码：3行-14行。

　 　经常可以看到有人把大量的代码放入单个try块，实际上这不是好习惯。这种现象之所以常见，原因就在于有些人图省事，不愿花时间分析一大块代码中哪几行 代码会抛出异常、异常的具体类型是什么。把大量的语句装入单个巨大的try块就象是出门旅游时把所有日常用品塞入一个大箱子，虽然东西是带上了，但要找出 来可不容易。

　　一些新手常常把大量的代码放入单个try块，然后再在catch语句中声明Exception，而不是分离各个可能出现异常的段落并分别捕获其异常。这种做法为分析程序抛出异常的原因带来了困难，因为一大段代码中有太多的地方可能抛出Exception。

　　结论五：尽量减小try块的体积。

　　反例之六：输出数据不完整

　　代码：7行-11行。

　 　不完整的数据是Java程序的隐形杀手。仔细观察这段代码，考虑一下如果循环的中间抛出了异常，会发生什么事情。循环的执行当然是要被打断的，其次， catch块会执行??就这些，再也没有其他动作了。已经输出的数据怎么办？使用这些数据的人或设备将收到一份不完整的（因而也是错误的）数据，却得不到 任何有关这份数据是否完整的提示。对于有些系统来说，数据不完整可能比系统停止运行带来更大的损失。

　　较为理想的处置办法是向输出设备写一些信息，声明数据的不完整性；另一种可能有效的办法是，先缓冲要输出的数据，准备好全部数据之后再一次性输出。

　　结论六：全面考虑可能出现的异常以及这些异常对执行流程的影响。

　　改写后的代码

　　根据上面的讨论，下面给出改写后的代码。也许有人会说它稍微有点?嗦，但是它有了比较完备的异常处理机制。

OutputStreamWriter out = ... java.sql.Connection conn = ... try { 　Statement stat = conn.createStatement(); 　ResultSet rs = stat.executeQuery( 　　"select uid, name from user"); 　while (rs.next()) 　{ 　　out.println("ID：" + rs.getString("uid") + "，姓名: " + rs.getString("name")); 　} } catch(SQLException sqlex) { 　out.println("警告：数据不完整"); 　throw new ApplicationException("读取数据时出现SQL错误", sqlex); } catch(IOException ioex) { 　throw new ApplicationException("写入数据时出现IO错误", ioex); } finally { 　if (conn != null) { 　　try { 　　　conn.close(); 　　} 　　catch(SQLException sqlex2) 　　{ 　　　System.err(this.getClass().getName() + ".mymethod - 不能关闭数据库连接: " + sqlex2.toString()); 　　} 　} 　if (out != null) { 　　try { 　　　out.close(); 　　} 　　catch(IOException ioex2) 　　{ 　　　System.err(this.getClass().getName() + ".mymethod - 不能关闭输出文件" + ioex2.toString()); 　　} 　} }

　　本文的结论不是放之四海皆准的教条，有时常识和经验才是最好的老师。如果你对自己的做法没有百分之百的信心，务必加上详细、全面的注释。

　 　另一方面，不要笑话这些错误，不妨问问你自己是否真地彻底摆脱了这些坏习惯。即使最有经验的程序员偶尔也会误入歧途，原因很简单，因为它们确确实实带来 了“方便”。所有这些反例都可以看作Java编程世界的恶魔，它们美丽动人，无孔不入，时刻诱惑着你。也许有人会认为这些都属于鸡皮蒜毛的小事，不足挂 齿，但请记住：勿以恶小而为之，勿以善小而不为。

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

Problem Statement
????
You are given a String[] cityMap representing the layout of a city. The city
consists of blocks. The first element of cityMap represents the first row of
blocks, etc. A 'B' character indicates a location where there is a bus stop.
There will be exactly one 'X' character, indicating your location. All other
characters will be '.'. You are also given an int walkingDistance, which is the
maximum distance you are willing to walk to a bus stop. The distance should be
calculated as the number of blocks vertically plus the number of blocks
horizontally. Return the number of bus stops that are within walking distance of
your current location. Definition
????
Class:
BusStops
Method:
countStops
Parameters:
String[], int
Returns:
int
Method signature:
int countStops(String[] cityMap, int walkingDistance)
(be sure your method is public)
????

Constraints
-
cityMap will contain between 1 and 50 elements, inclusive.
-
Each element of cityMap will contain between 1 and 50 characters, inclusive.
-
Each element of cityMap will contain the same number of characters.
-
Each character of each element of cityMap will be 'B', 'X', or '.'.
-
There will be exactly one 'X' character in cityMap.
-
walkingDistance will be between 1 and 100, inclusive.
Examples
0)

????
{"...B.",
 ".....",
 "..X.B",
 ".....",
 "B...."}
3
Returns: 2
You can reach the bus stop at the top (3 units away), or on the right (2 units
away). The one in the lower left is 4 units away, which is too far. 1)

????
{"B.B..",
 ".....",
 "B....",
 ".....",
 "....X"}
8
Returns: 3
A distance of 8 can get us anywhere on the map, so we can reach all 3 bus stops.
2)

????
{"BBBBB",
 "BB.BB",
 "B.X.B",
 "BB.BB",
 "BBBBB"}
1
Returns: 0
Plenty of bus stops, but unfortunately we cannot reach any of them.
3)

????
{"B..B..",
 ".B...B",
 "..B...",
 "..B.X.",
 "B.B.B.",
 ".B.B.B"}
3
Returns: 7

This problem statement is the exclusive and proprietary property of TopCoder,
Inc. Any unauthorized use or reproduction of this information without the prior
written consent of TopCoder, Inc. is strictly prohibited. (c)2003, TopCoder,
Inc. All rights reserved.

package org.jboss.collors;
public @interface Orange{}

package org.jboss.examples;
public class Foo
{
  @Orange void someMethod();
  @Orange private int someField;
}

public class BankAccount
{
public void withdraw(double amount)
{
long startTime = System.currentTimeMillis();
try
{
// Actual method body...
}
finally
{
long endTime = System.currentTimeMillis() - startTime;
System.out.println("withdraw took: " + endTime);
}
}
}

public class Metrics
{
public Object profile(MethodInvocation invocation) throws Throwable
{
long startTime = System.currentTimeMillis();
try
{
return invocation.invokeNext();
}
finally
{
long endTime = System.currentTimeMillis() - startTime;
java.lang.reflect.Method m = invocation.getMethod();
System.out.println("method " + m.toString() +
" time: " + endTime + "ms");
} }
}

<aop>
<aspect class="Metrics"/>
 
<bind pointcut="execution(public void BankAccount->withdraw(double amount))">
<advice name="profile" aspect="Metrics"/>
</bind>
</aop>

Import org.jboss.aspects.Oneway；
public class Foo
{
  @Oneway public static void someMethord（）{…}
public static void main(String[] args){
somMethod();//executes in
 backgroud
}
}

package org.jboss.aspects;
 
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
 
@Target({ElementType.METHOD})
public @interface Oneway {}

package org.jboss.aspects;
 
public OnewayAspect
{
private static class Task implements Runnable
{
private MethodInvocation invocation;
 
public Task(MethodInvocation invocation)
{
this.invocation = invocation;
}
public void run()
{
try { invocation.invokeNext(); }
catch (Throwable ignore) { }
}
}
 
 
public Object oneway(MethodInvocation invocation) throws Throwable
{
MethodInvocation copy = invocation.copy();
Thread t = new Thread(new Task(copy));
t.setDaemon(false);
t.start();
return null;
}
}

<aop>
<aspect class="org.jboss.aspects.OnewayAspect"/>
<bind pointcut="execution(void *->@org.jboss.Oneway(..))">
<advice name="oneway"
aspect="org.jboss.aspects.OnewayAspect"/>
</bind>
</aop>

import org.jboss.aspects.Threadbased;
public class Foo
{
@Threadbased private int counter;
}

package org.jboss.aspects;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@Target({ElementType.FIELD})
public @interface Threadbased {}

package org.jboss.aspects;
import org.jboss.aop.joinpoint.*;
import java.lang.reflect.Field;
public class ThreadbasedAspect
{
private ThreadLocal threadbased = new ThreadLocal();
public Object access(FieldReadInvocation invocation)
throws Throwable
{
// just in case we have a primitive,
// we can't return null
if (threadbased.get() == null)
return invocation.invokeNext();
return threadbased.get();
}
public Object access(FieldWriteInvocation invocation)
throws Throwable
{
threadbased.set(invocation.getValue());
return null;
}
}

<aop>
<aspect class="org.jboss.aspects.ThreadbasedAspect" scope="PER_JOINPOINT"/>
<bind pointcut="field(* *->@org.jboss.aspects.Threadbased)">
<advice name="access"
aspect="org.jboss.aspects.ThreadbasedAspect"/>
</bind>
</aop>

package org.jboss.aspects;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@Target({ElementType.FIELD})
public @interface Inject {}

package org.jboss.aspects;
import org.jboss.aop.joinpoint.*;
import java.lang.reflect.Field;
import javax.transaction.TransactionManager;
import org.jboss.tm.TxManager;
public InjectTMAspect
{
private TransactionManager tm = TxManager.getInstance();
public Object access(FieldReadInvocation invocation)
throws Throwable {
return tm;
}
public Object access(FieldWriteInvocation invocation)
throws Throwable {
throw new RuntimeException(
"Setting an @Injected variable is illegal");
}
}

<aop>
<aspect class="org.jboss.aspects.InjectTMAspect"/>
<bind pointcut="field(javax.transaction.TransactionManager *->@org.jboss.aspects.Inject)">
<advice name="access"
aspect="org.jboss.aspects.InjectTMAspect"/>
</bind>
</aop>

import javax.transaction.TransactionManager;
import org.jboss.aspects.Inject;
public class MyTransactionalCache
{
@Inject private TransactionManager tm;
...
}

public Foo {
@Asynchronous public int someMethod(int someArg) {...}
}

Foo foo = new Foo();
someMethod(555); // executes in background
AsynchronousFacade facade = (AsynchronousFacade)foo;
AsynchronousResponse response = facde.waitForResponse();
System.out.println(response.getReturnValue());

import org.jboss.aspects.txlock.TxSynchronized;
public FooBar
{
@TxSynchronized public FooBar() {}
@TxSynchronized static void staticMethod() {}
@TxSynchronized public memberMethod() {}
}

import org.jboss.aspects.tx.*;
public class Foo
{
@Tx(TxType.REQUIRED) public Foo {}
@Tx(TxType.REQUIRESNEW) public static createFoo() {
return new Foo();
}
}

import org.jboss.aspects.security.*;
@SecurityDomain("LDAP Repository")
public class Foo
{
@Permissions({"admin"}) public Foo() {}
@Permissions({"developer"}) public static int status;
@Permissions({"anybody"}) public static void doSomething() {...}
}

public MySessionBean
{
@Tx(TxType.REQUIRED) public static doSomething() {...}
}

Tiger 中的注释，第 2 部分: 定制注释

Write your own annotations in Java 5

文档选项 将此页作为电子邮件发送 未显示需要 JavaScript 的文档选项 对此页的评价 帮助我们改进这些内容 级别: 初级 Brett McLaughlin, 作者/编者, O'Reilly Media, Inc 2004 年 9 月 01 日 本系列文章的 第 1 部分介绍了注释 —— J2SE 5.0 中新的元数据工具，并重点讨论了 Tiger 的基本内置注释。一个更强大的相关特性是支持编写自己的注释。本文中，Brett McLauglin 说明了如何创建定制注释，如何用自己的注释注解文档，并进一步定制代码。 本系列的第一篇文章 介绍了什么是元数据，元数据的重要性，以及如何使用 J2SE 5.0（也叫做 Tiger）的基本内置注释。如果习惯了这些概念，您可能已经在想，Java 5 提供的三种标准注释也并不是特别健壮，能使用的只有 Deprecated 、 SuppressWarnings 和 Override 而已。所幸的是，Tiger 还允许定义自己的注释类型。在本文中，我将通过一些示例引导您掌握这个相对简单的过程。您还将了解如何对自己的注释进行注解，以及这样做的一些好处。我要 感谢 O'Reilly Media, Inc.，他们非常慷慨地允许我在本文中使用我关于 Tiger 的书籍的“注释”一章中的代码示例（请参阅 参考资料）。 定义自己的注释类型 通过添加了一个小小的语法（Tiger 添加了大量的语法结构），Java 语言支持一种新的类型 —— 注释类型（annotation type）。注释类型看起来很像普通的类，但是有一些特有的性质。最明显的一点是，可以在类中以符号（ @ ）的形式注释其他 Java 代码。我将一步一步地介绍这个过程。 @interface 声明 定义新的注释类型与创建接口有很多类似之处，只不过 interface 关键字之前要有一个 @ 符号。清单 1 中给出的是一个最简单的注释类型的示例： 清单 1. 非常简单的注释类型 package com.oreilly.tiger.ch06; /** * Marker annotation to indicate that a method or class * is still in progress. */ public @interface InProgress { } 清单 1 的含义非常明显。如果编译这个注释类型，并确信其位于类路径中，那么您就可以在自己的源代码方法中使用它，以指出某个方法或类仍在处理中，如清单 2 所示： 清单 2. 使用定制的注释类型 @com.oreilly.tiger.ch06.InProgress public void calculateInterest(float amount, float rate) { // Need to finish this method later } 清单 1 所示注释类型的使用方法和内置注释类型的使用方法完全相同，只不过要同时使用名称和所在的包来指示定制注释。当然，一般的 Java 规则仍然适用，您可以导入该注释类型，直接使用 @InProgress 引用它。 不要漏掉本系列的另一部分 一定要阅读本系列文章的“ 第 1 部分”，其中介绍了 Java 5.0 中的注释。 添加成员 上面所示的基本用法还远远不够健壮。您一定还记得“第 1 部分”中曾经提到的，注释类型可以有成员变量（请参阅 参考资料）。 这一点非常有用，尤其是准备将注释作为更加复杂的元数据，而不仅仅将它作为原始文档使用的时候。代码分析工具喜欢加工大量的信息，定制注释可以提供这类信息。 注释类型中的数据成员被设置成使用有限的信息进行工作。定义数据成员后不需要分别定义访问和修改的方法。相反，只需要定义一个方法，以成员的名称命名它。数据类型应该是该方法返回值的类型。清单 3 是一个具体的示例，它澄清了一些比较含糊的要求： 清单 3. 向注释类型添加成员 package com.oreilly.tiger.ch06; /** * Annotation type to indicate a task still needs to be * completed. */ public @interface TODO { String value(); } 尽管清单 3 看起来很奇怪，但这是注释类型所要求的格式。清单 3 定义了一个名为 value 的字符串，该注释类型能够接受它。然后，就可以像清单 4 中那样使用注释类型： 清单 4. 使用带有成员值的注释类型 @com.oreilly.tiger.ch06.InProgress @TODO("Figure out the amount of interest per month") public void calculateInterest(float amount, float rate) { // Need to finish this method later } 这里同样没有多少花样。清单 4 假设已经引入了 com.oreilly.tiger.ch06.TODO ，因此源代码中的注释 不 需要包名作前缀。此外，需要注意的是，清单 4 中采用了简写的方法：将值 （"Figure out the amount of interest per month"） 直接提供给注释，没有指定成员变量名。清单 4 和清单 5 是等价的，后者没有采用简写形式： 清单 5. 清单 4 的“加长”版 @com.oreilly.tiger.ch06.InProgress @TODO(value="Figure out the amount of interest per month") public void calculateInterest(float amount, float rate) { // Need to finish this method later } 当然作为编码人员，我们都不愿意跟这种“加长”版搅在一起。不过要注意，只有当注释类型只有 一个 成员变量，而且变量名为 value 时，才能使用简写形式。如果不符合这个条件，那么就无法利用这种特性。 设置默认值 迄 今为止，您已经有了一个很好的起点，但是要做得完美，还有很长的一段路要走。您可能已经想到，下一步就要为注释设置某个默认值。如果您希望用户指定某些 值，但是只有这些值与默认值不同的时候才需要指定其他的值，那么设置默认值就是一种很好的办法。清单 6 用另一个定制注释 —— 来自 清单 4 的 TODO 注释类型的一个全功能版本，示范了这个概念及其实现： 清单 6. 带有默认值的注释类型 package com.oreilly.tiger.ch06; public @interface GroupTODO { public enum Severity { CRITICAL, IMPORTANT, TRIVIAL, DOCUMENTATION }; Severity severity() default Severity.IMPORTANT; String item(); String assignedTo(); String dateAssigned(); } 清单 6 中的 GroupTODO 注释类型中添加了几个新的变量。因为该注释类型的成员变量不是一个，所以将一个变量命名为 value 没有任何意义。只要成员变量多于一个，就应该尽可能准确地为其命名。因为不可能从 清单 5所示的简写形式中获益，所以您需要创建虽然稍微有点冗长，但是更容易理解的注释类型。 清单 6 中出现的另一个新特性是注释类型定义了自己的枚举（枚举，即 enumeration，通常也称为 enums，是 Java 5 的另一个新特性。它并没有多么地不同凡响，对注释类型更是如此）。然后，清单 6 使用新定义的枚举作为一个成员变量的类型。 最后，再回到我们的主题 —— 默认值。建立默认值的过程非常琐碎，需要在成员声明的后面添加关键字 default ，然后提供默认值。正如您所料，默认值的类型必须与成员变量声明的类型完全相同。同样，这也不是什么火箭科学，只不过是词法上的变异。清单 7 给出了一个具体应用中的 GroupTODO 注释，其中 没有 指定 severity 成员： 清单 7. 使用默认值 @com.oreilly.tiger.ch06.InProgress @GroupTODO( item="Figure out the amount of interest per month", assignedTo="Brett McLaughlin", dateAssigned="08/04/2004" ) public void calculateInterest(float amount, float rate) { // Need to finish this method later } 清单 8 中使用了同一个注释，但这一次给出了 severity 的值： 清单 8. 改写默认值 @com.oreilly.tiger.ch06.InProgress @GroupTODO( severity=GroupTODO.Severity.DOCUMENTATION, item="Need to explain how this rather unusual method works", assignedTo="Jon Stevens", dateAssigned="07/30/2004" ) public void reallyConfusingMethod(int codePoint) { // Really weird code implementation } 回页首 对注释的注释 结 束关于注释的讨论之前（至少在本系列文章中），我想简要地讨论一下注释的注释。第 1 部分中所接触的预定义注释类型都有预定义的目的。但是在编写自己的注释类型时，注释类型的目的并不总是显而易见的。除了基本的文档外，可能还要针对某个特 定的成员类型或者一组成员类型编写类型。这就要求您为注释类型提供某种元数据，以便编译器保证按照预期的目的使用注释。 当然，首先想到的就是 Java 语言选择的元数据形式 —— 注释。您可以使用 4 种预定义的注释类型（称为 元注释）对您的注释进行注释。我将对这 4 种类型分别进行介绍。 指定目标 最明显的元注释就是允许何种程序元素具有定义的注释类型。毫不奇怪，这种元注释被称为 Target 。但是在了解如何使用 Target 之前，您还需要认识另一个类，该类被称为 ElementType ，它实际上是一个枚举。这个枚举定义了注释类型可应用的不同程序元素。清单 9 给出了完整的 ElementType 枚举： 清单 9. ElementType 枚举 package java.lang.annotation; public enum ElementType { TYPE, // Class, interface, or enum (but not annotation) FIELD, // Field (including enumerated values) METHOD, // Method (does not include constructors) PARAMETER, // Method parameter CONSTRUCTOR, // Constructor LOCAL_VARIABLE, // Local variable or catch clause ANNOTATION_TYPE, // Annotation Types (meta-annotations) PACKAGE // Java package } 清单 9 中的枚举值意义很明确，您自己可以分析其应用的目标（通过后面的注解）。使用 Target 元注释时，至少要提供这些枚举值中的一个并指出注释的注释可以应用的程序元素。清单 10 说明了 Target 的用法： 清单 10. 使用 Target 元注释 package com.oreilly.tiger.ch06; import java.lang.annotation.ElementType; import java.lang.annotation.Target; /** * Annotation type to indicate a task still needs to be completed */ @Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.ANNOTATION_TYPE}) public @interface TODO { String value(); } 现在，Java 编译器将把 TODO 应用于类型、方法、构造函数和其他注释类型。这样有助于避免他人误用您的注释类型（或者最好的地方是， 您自己也不会因为疲惫而误用它）。 设置保持性 下一个要用到的元注释是 Retention 。这个元注释和 Java 编译器处理注释的注释类型的方式有关。编译器有几种不同选择： 将注释保留在编译后的类文件中，并在第一次加载类时读取它。 将注释保留在编译后的类文件中，但是在运行时忽略它。 按照规定使用注释，但是并不将它保留到编译后的类文件中。 这三种选项用 java.lang.annotation.RetentionPolicy 枚举表示，如清单 11 所示： 清单 11. RetentionPolicy 枚举 package java.lang.annotation; public enum RetentionPolicy { SOURCE, // Annotation is discarded by the compiler CLASS, // Annotation is stored in the class file, but ignored by the VM RUNTIME // Annotation is stored in the class file and read by the VM } 现在可以看出， Retention 元注释类型使用清单 11 所示的枚举值中的一个作为惟一的参数。可以将该元注释用于您的注释，如清单 12 所示： 清单 12. 使用 Retention 元注释 @Retention(RetentionPolicy.SOURCE) public @interface SuppressWarnings { // annotation type body } 如清单 12 所示，这里可以使用简写形式，因为 Retention 只有一个成员变量。如果要将保持性设为 RetentionPolicy.CLASS ，那么什么也不需要做，因为这就是默认行为。 添加公共文档 下一个元注释是 Documented 。这个元注释也非常容易理解，部分原因是 Documented 是一个标记注释。您应该还记得第 1 部分中曾经提到，标记注释没有成员变量。 Documented 表示注释应该出现在类的 Javadoc 中。在默认情况下，注释 不包括在 Javadoc 中，如果花费大量时间注释一个类、详细说明未完成的工作、正确完成了什么或者描述行为，那么您应该记住这一点。 清单 13 说明了 Documented 元注释的用法： 清单 13. 使用 Documented 元注释 package com.oreilly.tiger.ch06; import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; /** * Marker annotation to indicate that a method or class * is still in progress. */ @Documented @Retention(RetentionPolicy.RUNTIME) public @interface InProgress { } Documented 的一个实用技巧是保持性策略。注意，清单 13 中规定注释的保持性（retention）是 RUNTIME ，这是使用 Documented 注释类型所 必需的。Javadoc 使用虚拟机从其类文件（而非源文件）中加载信息。确保 VM 从这些类文件中获得生成 Javadoc 所需信息的惟一方法是将保持性规定为 RetentionPolicy.RUNTIME 。这样，注释就会保留在编译后的类文件中 并且由虚拟机加载，然后 Javadoc 可以从中抽取出来添加到类的 HTML 文档中。 设置继承 最后一个元注释 Inherited ，可能是最复杂、使用最少、也最容易造成混淆的一个。这就是说，我们简单地看一看就可以了。 首先考虑这样一种情况：假设您通过定制的 InProgress 注释标记一个类正在开发之中，这完全没有问题，对吧？这些信息还会出现在 Javadoc 中，只要您正确地应用了 Documented 元注释。现在，假设您要编写一个新类，扩展那个还在开发之中的类，也不难，是不是？但是要记住，那个超类还在开发之中。如果您使用子类，或者查看它的文档，根本没有线索表明还有什么地方没有完成。您本来希望看到 InProgress 注释被带到子类中 —— 因为这是 继承 的 —— 但情况并非如此。您必须使用 Inherited 元注释说明所期望的行为，如清单 14 所示： 清单 14. 使用 Inherited 元注释 package com.oreilly.tiger.ch06; import java.lang.annotation.Documented; import java.lang.annotation.Inherited; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; /** * Marker annotation to indicate that a method or class * is still in progress. */ @Documented @Inherited @Retention(RetentionPolicy.RUNTIME) public @interface InProgress { } 添加 @Inherited 后，您将看到 InProgress 出现在注释类的子类中。当然，您并不希望所有的注释类型都具有这种行为（因此默认值是 不 继承的）。比如， TODO 注释就不会（也不应该）被传播。但是对于这里示范的情况， Inherited 可能非常有用。 回页首 结束语 现 在，您也许已经准备回到 Java 世界为所有的事物编写文档和注释了。这不禁令我回想起人们了解 Javadoc 之后发生的事情。我们都陷入了文档过滥的泥潭，直到有人认识到最好使用 Javadoc 来理清容易混淆的类或者方法。无论用 Javadoc 做了多少文章，也没有人会去看那些易于理解的 getXXX() 和 setXXX() 方法。 注 释也可能出现同样的趋势，虽然不一定到那种程度。经常甚至频繁地使用标准注释类型是一种较好的做法。所有的 Java 5 编译器都支持它们，它们的行为也很容易理解。但是，如果要使用定制注释和元注释，那么就很难保证花费很大力气创建的那些类型在您的开发环境之外还有什么意 义。因此要慎重。在合理的情况下使用注释，不要荒谬使用。无论如何，注释都是一种很好的工具，可以在开发过程中提供真正的帮助。 回页首 参考资料 您可以参阅本文在 developerWorks 全球站点上的 英文原文。 不要遗漏“ Tiger 中的注释，第 2 部分”，即本系列文章的第 2 部分，研究了定制注释。 开放源代码 XDoclet代码生成引擎支持面向属性的 Java 语言编程。 JSR 175，将元数据工具合并到 Java 语言中的规范，处于 Java Community Process 的提议最终草案状态。 访问 Sun 的主页，获取 J2SE 5.0 的所有信息。 可以 下载 Tiger并自己试用。 John Zukowski 的系列文章 Taming Tiger 以实用的基于技巧的形式讲述了 Java 5.0 的新功能。 由 Brett McLaughlin 和 David Flanagan 撰写的 Java 1.5 Tiger: A Developer's Notebook 一书 (O'Reilly & Associates; 2004)，以代码为中心、开发人员友好的形式，讲述了几乎所有的 Tiger 的最新功能 — 包括注释。 在 developerWorksJava 技术专区 可以找到数百篇有关 Java 技术的参考资料。 访问 Developer Bookstore，获得技术书籍的完整列表，其中包括数百本 Java 相关主题的书籍。 是否对无需通常的高成本入口点（entry point）或短期评估许可证的 IBM 测试产品感兴趣？ developerWorks Subscription为 WebSphere?、DB2?、Lotus?、Rational? 和 Tivoli? 产品提供了低成本的 12 个月单用户许可证，包括基于 Eclipse 的 WebSphere Studio? IDE，用于开发、测试、评估和展示您的应用程序。 回页首 关于作者 Brett McLaughlin 从 Logo 时代（还记得那个小三角吗？）就开始从事计算机工作。在最近几年里，他已经成为 Java 和 XML 社区最知名的作者和程序员之一。他曾经在 Nextel Communications 实现复杂的企业系统，在 Lutris Technologies 编写应用程序服务器，目前在为 O'Reilly Media, Inc 撰写和编辑 书籍。

Tiger 中的注释，第 1 部分: 向 Java 代码中添加元数据

如何使用 Java 5 的内置注释

文档选项 将此页作为电子邮件发送 未显示需要 JavaScript 的文档选项 对此页的评价 帮助我们改进这些内容 级别: 初级 Brett McLaughlin, 作者/编者, O'Reilly Media, Inc 2004 年 9 月 01 日 注 释，J2SE 5.0 (Tiger) 中的新功能，将非常需要的元数据工具引入核心 Java 语言。该系列文章分为两部分，在这第 1 部分中，作者 Brett McLaughlin 解释了元数据如此有用的原因，向您介绍了 Java 语言中的注释，并研究了 Tiger 的内置注释。 编程的一个最新的趋势，尤其是在 Java 编程方面，是使用 元数据。简单地说，元数据就是 关于数据的数据。元数据可以用于创建文档，跟踪代码中的依赖性，甚至执行基本编译时检查。许多元数据工具，如 XDoclet（请参阅 参考资料），将这些功能添加到核心 Java 语言中，暂时成为 Java 编程功能的一部分。 直到可以使用 J2SE 5.0（也叫做 Tiger，现在是第二个 beta 版本），核心 Java 语言才最接近具有 Javadoc 方法的元数据工具。您使用特殊的标签集合来标记代码，并执行 javadoc 命令来将这些标签转化成格式化的 HTML 页面，该页面说明标签所附加到的类。然而，Javadoc 是有缺陷的元数据工具，因为除了生成文档之外，您没有固定、实用、标准化的方式来将数据用于其他用途。HTML 代码经常混入到 Javadoc 输出中这一事实甚至更进一步降低了其用于任何其他目的的价值。 Tiger 通过名为 注释的新功能将一个更通用的元数据工 具合并到核心 Java 语言中。注释是可以添加到代码中的修饰符，可以用于包声明、类型声明、构造函数、方法、字段、参数和变量。Tiger 包含内置注释，还支持您自己编写的定制注释。本文将概述元数据的优点并向您介绍 Tiger 的内置注释。本系列文章的 第 2 部分将研究定制注释。我要感谢 O'Reilly Media, Inc.，他们非常慷慨地 允许我在本文中使用我关于 Tiger 的书籍的“注释”一章中的代码示例（请参阅 参考资料）。 元数据的价值 一 般来说，元数据的好处分为三类：文档编制、编译器检查和代码分析。代码级文档最常被引用。元数据提供了一种有用的方法来指明方法是否取决于其他方法，它们 是否完整，特定类是否必须引用其他类，等等。这确实非常有用，但对于将元数据添加到 Java 语言中来说，文档编制可能是 最不相关的理由。Javadoc 已经提供了非常容易理解和健壮的方法来文档化代码。另外，当已经存在文档编制工具，并且在大多数时候都工作得很好时，谁还要编写文档编制工具？ 不要漏掉本系列的另一部分 一定要阅读本系列的“ 第 2 部分”，该部分研究了定制注释。 编译器检查 元数据更重要的优点是编译器可以使用它来执行基本的编译时检查。例如，您将在本文后面的 Override 注释中 看到 Tiger 引入了一个这样的注释，用于允许您指定一种方法覆盖超类中的另一种方法。Java 编译器可以确保在元数据中指明的行为实际发生在代码级别。如果从来没有找出过这种类型的 bug，这样做似乎有点傻，但是大多数年龄很大的 Java 编程老手都曾经花费至少多个晚上来查明他们的代码为什么不能用。当最后认识到方法的参数有错，且该方法实际上 没有 覆盖超类中的方法时，您可能更感到难受。使用元数据的工具有助于轻松地查明这种类型的错误，从而可以节省那些晚上来看长期进行的 Halo 联赛。 JSR 175 JSR 175， Java 编程语言的元数据工具，为将元数据合并到核心 Java 语言中提供了正式理由和说明（请参阅 参考资料）。根据 JSR，注释“不直接影响程序的语义。然而，开发和部署工具可以读取这些注释，并以某种形式处理这些注释，可能生成其他 Java 编程语言源文件、XML 文档或要与包含注释的程序一起使用的其他构件。” 代码分析 可 以证明，任何好的注释或元数据工具的最好功能就是可以使用额外数据来分析代码。在一个简单的案例中，您可能构建代码目录，提供必需的输入类型并指明返回类 型。但是，您可能想，Java 反射具有相同的优点；毕竟，可以为所有这些信息内省代码。这从表面上看似乎是正确的，但是在实际中通常不使用。许多时候，方法作为输入接受的或者作为输出 返回的类型实际上不是该方法想要的类型。例如，参数类型可能是 Object ，但方法可能仅使用 Integer 。这在好些情况下很容易发生，比如在方法被覆盖而超类使用常规参数声明方法时，还有正在进行许多序列化的系统中也容易发生。在这两种情况中，元数据可以指示代码分析工具，虽然参数类型是 Object ，但 Integer 才是真正需要的。这类分析非常有用，但也不能夸大它的价值。 在 更复杂的情况下，代码分析工具可以执行所有种类的额外任务。示例 du jour 是 Enterprise JavaBean (EJB) 组件。甚至简单 EJB 系统中的依赖性和复杂性都非常令人吃惊。您具有了 home 接口和远程接口，以及本地接口和本地 home 接口，还有一个实现类。保持所有这些类同步非常困难。但是，元数据可以提供这个问题的解决放案。好的工具（还是要提一下 XDoclet）可以管理所有这些依赖性，并确保无“代码级”连接、但有“逻辑级”捆绑的类保持同步。元数据在这里确实可以发挥它的作用。 回页首 注释的基本知识 现在已经了解了元数据的好处，我将介绍 Tiger 中的注释。注释采用“at”标记形式 ( @ )，后面是注释名称。然后在需要数据时，通过 name=value 对向注释提供数据。每次使用这类表示法时，就是在生成注释。一段代码可能会有 10 个、50 个或更多的注释。不过，您将发现多个注释都可能使用相同的 注释类型。类型是实际使用的结构，在特定上下文中，注释本身是该类型的具体使用（请参阅侧栏 注释或注释类型？）。 注释或注释类型？ 是否对什么是注释与什么是注释类型感到迷惑？了解这个的最简单方法就是对比所熟悉的 Java 语言概念来想。可以定义一个类（例如 Person ），则在 JVM 中将总是仅有该类的一个版本（假设没有进行麻烦的类路径设置）。然而，在任何给定时间，可能会使用该类的 10 个或 20 个 实例。仍然是只有一个 Person 类，但是它以不同的方式使用多次。注释类型和注释也是这样。注释类型类似于类，注释类似于该类的实例。 注释分为三个基本种类： 标记注释没有变量。注释显示简单，由名称标识，没有提供其他数据。例如， @MarkerAnnotation 是标记注释。它不包含数据，仅有注释名称。 单一值注释与标记注释类似，但提供一段数据。因为仅提供很少的一点数据，所以可以使用快捷语法（假设注释类型接受此语法）： @SingleValueAnnotation("my data") 。除了 @ 标记外，这应该与普通的 Java 方法调用很像。 完整注释有多个数据成员。因此，必须使用更完整的语法（注释不再像普通的 Java 方法）： @FullAnnotation(var1="data value 1", var2="data value 2", var3="data value 3") 。 除了通过默认语法向注释提供值外，还可以在需要传送多个值时使用名称-值对。还可以通过花括号为注释变量提供值数组。清单 1 显示了注释中的值数组的示例。 清单 1. 在注释中使用按数组排列的值 @TODOItems({ // Curly braces indicate an array of values is being supplied @TODO( severity=TODO.CRITICAL, item="Add functionality to calculate the mean of the student's grades", assignedTo="Brett McLaughlin" ), @TODO( severity=TODO.IMPOTANT, item="Print usage message to screen if no command-line flags specified", assignedTo="Brett McLaughlin" ), @TODO( severity=TODO.LOW, item="Roll a new website page with this class's new features", assignedTo="Jason Hunter" ) }) 清单 1 中的示例并没有乍一看那样复杂。 TODOItems 注释类型有一个具有值的变量。这里提供的值比较复杂，但 TODOItems 的使用实际与单一值注释类型相符，只是这里的单一值是数组而已。该数组包含三个 TODO 注释，其中每个注释都是多值的。逗号分隔每个注释内的值，以及单个数组内的值。非常容易，是吧？ 但是我讲的可能超前了些。 TODOItems 和 TODO 是 定制注释， 是本系列文章第 2 部分中的主题。但是我想让您看到，即使复杂注释（清单 1 几乎是最复杂的注释）也不是非常令人害怕的。当提到 Java 语言的标准注释类型时，将很少看到如此复杂的情况。正如将在下面三个部分了解到的，Tiger 的基本注释类型的使用都极其简单。 回页首 Override 注释 Tiger 的第一个内置注释类型是 Override 。 Override 应该仅用于方法（不用于类、包声明或其他构造）。它指明注释的方法将覆盖超类中的方法。清单 2 显示了简单的示例。 清单 2. 操作中的 Override 注释 package com.oreilly.tiger.ch06; public class OverrideTester { public OverrideTester() { } @Override public String toString() { return super.toString() + " [Override Tester Implementation]"; } @Override public int hashCode() { return toString().hashCode(); } } 清单 2 应该很容易理解。 @Override 注释对两个方法进行了注释 — toString() 和 hashCode() ，来指明它们覆盖 OverrideTester 类的超类 ( java.lang.Object ) 中的方法的版本。开始这可能看起来没什么作用，但它实际上是非常好的功能。如果不覆盖这些方法，根本 无法 编译此类。该注释还确保当您将 toString() 弄乱时，至少还有某种指示，即应该确保 hashCode() 仍旧匹配。 当编码到很晚且输错了某些东西时，此注释类型真的可以发挥很大的作用，如清单 3 中所示。 清单 3. 使 Override 注释捕获打字稿 package com.oreilly.tiger.ch06; public class OverrideTester { public OverrideTester() { } @Override public String toString() { return super.toString() + " [Override Tester Implementation]"; } @Override public int hasCode() { return toString().hashCode(); } } 在清单 3 中， hashCode() 错误地输入为 hasCode() 。注释指明 hasCode() 应该覆盖方法。但是在编译中， javac 将发现超类 ( java.lang.Object ) 没有名为 hasCode() 的方法可以覆盖。因此，编译器将报错，如图 1 中所示。 图 1. 来自 Override 注释的编译器警告 缺少的功能 在单一值注释类型中，如果 Deprecated 允许包含错误类型消息将更好。然后，当用户使用声明为过时的方法时，编译器可以打印消息。该消息可以指明使用方法的结果如何重要，说明何时将停止方法，甚至建议备用方法。可能 J2SE 的下一版本（“Mustang”，他们这样命名）将提供这种功能。 这个便捷的小功能将帮助快速捕获打字稿。 回页首 Deprecated 注释 下一个标准注释类型是 Deprecated 。与 Override 一样， Deprecated 是标记注释。正如您可能期望的，可以使用 Deprecated 来对不应再使用的方法进行注释。与 Override 不一样的是， Deprecated 应该与正在声明为过时的方法放在同一行中（为什么这样？说实话我也不知道），如清单 4 中所示。 清单 4. 使用 Deprecated 注释 package com.oreilly.tiger.ch06; public class DeprecatedClass { @Deprecated public void doSomething() { // some code } public void doSomethingElse() { // This method presumably does what doSomething() does, but better } } 单独编译此类时，不会发生任何不同。但是如果通过覆盖或调用来使用声明为过时的方法，编译器将处理注释，发现不应该使用该方法，并发出错误消息，如图 2 中所示。 图 2. 来自 Deprecated 注释的编译器警告 注意需要开启编译器警告，就像是必须向 Java 编译器指明想要普通的声明为过时警告。可以使用下列两个标记之一和 javac 命令： -deprecated 或新的 -Xlint:deprecated 标记。 回页首 SuppressWarnings 注释 从 Tiger “免费”获得的最后一个注释类型是 SuppressWarnings 。发现该类型的作用应该不难，但是 为什么该注释类型如此重要通常不是很明显。它实际上是 Tiger 的所有新功能的副功能。例如，以泛型为例；泛型使所有种类的新类型安全操作成为可能，特别是当涉及 Java 集合时。然而，因为泛型，当使用集合而 没有 类型安全时，编译器将抛出警告。这对于针对 Tiger 的代码有帮助，但它使得为 Java 1.4.x 或更早版本编写代码非常麻烦。将不断地收到关于根本无关的事情的警告。如何才能使编译器不给您增添麻烦？ SupressWarnings 可以解决这个问题。 SupressWarnings 与 Override 和 Deprecated 不同， 是具有变量的 — 所以您将单一注释类型与该变量一起使用。可以以值数组来提供变量，其中每个值指明要阻止的一种特定警告类型。请看清单 5 中的示例，这是 Tiger 中通常会产生错误的一些代码。 清单 5. 不是类型安全的 Tiger 代码 public void nonGenericsMethod() { List wordList = new ArrayList(); // no typing information on the List wordList.add("foo"); // causes error on list addition } 图 3 显示了清单 5 中代码的编译结果。 图 3. 来自非标准代码的编译器警告 清单 6 通过使用 SuppressWarnings 注释消除了这种问题。 清单 6. 阻止警告 @SuppressWarings(value={"unchecked"}) public void nonGenericsMethod() { List wordList = new ArrayList(); // no typing information on the List wordList.add("foo"); // causes error on list addition } 非常简单，是吧？仅需要找到警告类型（图 3 中显示为“unchecked”），并将其传送到 SuppressWarnings 中。 SuppressWarnings 中变量的值采用数组，使您可以在同一注释中阻止多个警告。例如， @SuppressWarnings(value={"unchecked", "fallthrough"}) 使用两个值的数组。此功能为处理错误提供了非常灵活的方法，无需进行大量的工作。 回页首 结束语 虽 然这里看到的语法可能都是新的，但您应该知道注释非常容易理解和使用。也就是说，与 Tiger 一起提供的标准注释相当简单，可以添加许多功能。元数据正日益变得有帮助，您肯定会提出非常适用于自己的应用程序的注释类型。在本系列文章的第 2 部分，我将详细说明 Tiger 对编写自己的注释类型的支持。您将了解如何创建 Java 类以及将其定义为注释类型，如何使编译器识别您的注释类型，以及如何使用该类型对代码进行注释。我甚至会更深入地说明奇异但有用的对注释进行注释的任务。 您将快速熟悉 Tiger 中的这一新构造。 回页首 参考资料 您可以参阅本文在 developerWorks 全球站点上的 英文原文。 不要遗漏“ Tiger 中的注释，第 2 部分”，即本系列文章的第 2 部分，研究了定制注释。 开放源代码 XDoclet代码生成引擎支持面向属性的 Java 语言编程。 JSR 175，将元数据工具合并到 Java 语言中的规范，处于 Java Community Process 的提议最终草案状态。 访问 Sun 的主页，获取 J2SE 5.0 的所有信息。 可以 下载 Tiger并自己试用。 John Zukowski 的系列文章 Taming Tiger 以实用的基于技巧的形式讲述了 Java 5.0 的新功能。 由 Brett McLaughlin 和 David Flanagan 撰写的 Java 1.5 Tiger: A Developer's Notebook 一书 (O'Reilly & Associates; 2004)，以代码为中心、开发人员友好的形式，讲述了几乎所有的 Tiger 的最新功能 — 包括注释。 在 developerWorksJava 技术专区 可以找到数百篇有关 Java 技术的参考资料。 访问 Developer Bookstore，获得技术书籍的完整列表，其中包括数百本 Java 相关主题的书籍。 是否对无需通常的高成本入口点（entry point）或短期评估许可证的 IBM 测试产品感兴趣？ developerWorks Subscription为 WebSphere?、DB2?、Lotus?、Rational? 和 Tivoli? 产品提供了低成本的 12 个月单用户许可证，包括基于 Eclipse 的 WebSphere Studio? IDE，用于开发、测试、评估和展示您的应用程序。 回页首 关于作者 Brett McLaughlin 从 Logo 时代（还记得那个小三角吗？）就开始从事计算机工作。在最近几年里，他已经成为 Java 和 XML 社区最知名的作者和程序员之一。他曾经在 Nextel Communications 实现复杂的企业系统，在 Lutris Technologies 编写应用程序服务器，目前在为 O'Reilly Media, Inc 撰写和编辑 书籍。

    /**
     * Describes the Request-For-Enhancement(RFE) that led
     * to the presence of the annotated API element.
     */
    public @interface RequestForEnhancement {
        int    id();
        String synopsis();
        String engineer() default "[unassigned]"; 
        String date();    default "[unimplemented]"; 
    }

    @RequestForEnhancement(
        id       = 2868724,
        synopsis = "Enable time-travel",
        engineer = "Mr. Peabody",
        date     = "4/1/3007"
    )
    public static void travelThroughTime(Date destination) { ... }

    /**
     * Indicates that the specification of the annotated API element
     * is preliminary and subject to change.
     */
    public @interface Preliminary { }

    @Preliminary public class TimeTravel { ... }

    /**
     * Associates a copyright notice with the annotated API element.
     */
    public @interface Copyright {
        String value();
    }

    @Copyright("2002 Yoyodyne Propulsion Systems")
    public class OscillationOverthruster { ... }

    import java.lang.annotation.*;

    /**
     * Indicates that the annotated method is a test method.
     * This annotation should be used only on parameterless static methods.
     */
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    public @interface Test { }

    public class Foo {
        @Test public static void m1() { }
        public static void m2() { }
        @Test public static void m3() {
            throw new RuntimeException("Boom");
        }
        public static void m4() { }
        @Test public static void m5() { }
        public static void m6() { }
        @Test public static void m7() {
            throw new RuntimeException("Crash");
        }
        public static void m8() { }
    }

Here is the testing tool:

    import java.lang.reflect.*;

    public class RunTests {
       public static void main(String[] args) throws Exception {
          int passed = 0, failed = 0;
          for (Method m : Class.forName(args[0]).getMethods()) {
             if (m.isAnnotationPresent(Test.class)) {
                try {
                   m.invoke(null);
                   passed++;
                } catch (Throwable ex) {
                   System.out.printf("Test %s failed: %s %n", m, ex.getCause());
                   failed++;
                }
             }
          }
          System.out.printf("Passed: %d, Failed %d%n", passed, failed);
       }
    }

    $ java RunTests Foo
    Test public static void Foo.m3() failed: java.lang.RuntimeException: Boom 
    Test public static void Foo.m7() failed: java.lang.RuntimeException: Crash 
    Passed: 2, Failed 2

package com.bjinfotech.practice.annotation;

/**
 * 演示如何使用java5内建的annotation
 * 参考资料：
 * http://java.sun.com/docs/books/tutorial/java/javaOO/annotations.html
 * http://java.sun.com/j2se/1.5.0/docs/guide/language/annotations.html
 * http://mindprod.com/jgloss/annotations.html
 * @author cleverpig
 *
 */
import java.util.List;

public class UsingBuiltInAnnotation {
        //食物类
        class Food{}
        //干草类
        class Hay extends Food{}
        //动物类
        class Animal{
                Food getFood(){
                        return null;
                }
                //使用Annotation声明Deprecated方法
                @Deprecated
                void deprecatedMethod(){
                }
        }
        //马类-继承动物类
        class Horse extends Animal{
                //使用Annotation声明覆盖方法
                @Override
                Hay getFood(){
                        return new Hay();
                }
                //使用Annotation声明禁止警告
                @SuppressWarnings({"deprecation","unchecked"})
                void callDeprecatedMethod(List horseGroup){
                        Animal an=new Animal();
                        an.deprecatedMethod();
                        horseGroup.add(an);
                }
        }
}

package com.bjinfotech.practice.annotation;

import java.lang.annotation.*;
/**
 * 定义annotation
 * @author cleverpig
 *
 */
//加载在VM中，在运行时进行映射
@Retention(RetentionPolicy.RUNTIME)
//限定此annotation只能标示方法
@Target(ElementType.METHOD)
public @interface AnnotationDefineForTestFunction{}

package com.bjinfotech.practice.annotation;

import java.lang.reflect.*;

/**
 * 一个实例程序应用前面定义的Annotation：AnnotationDefineForTestFunction
 * @author cleverpig
 *
 */
public class UsingAnnotation {
        @AnnotationDefineForTestFunction public static void method01(){}
        
        public static void method02(){}
        
        @AnnotationDefineForTestFunction public static void method03(){
                throw new RuntimeException("method03");
        }
        
        public static void method04(){
                throw new RuntimeException("method04");
        }
        
        public static void main(String[] argv) throws Exception{
                int passed = 0, failed = 0;
                //被检测的类名
                String className="com.bjinfotech.practice.annotation.UsingAnnotation";
                //逐个检查此类的方法，当其方法使用annotation声明时调用此方法
            for (Method m : Class.forName(className).getMethods()) {
               if (m.isAnnotationPresent(AnnotationDefineForTestFunction.class)) {
                  try {
                     m.invoke(null);
                     passed++;
                  } catch (Throwable ex) {
                     System.out.printf("测试 %s 失败: %s %n", m, ex.getCause());
                     failed++;
                  }
               }
            }
            System.out.printf("测试结果： 通过: %d, 失败： %d%n", passed, failed);
        }
}

将 Java Swing 应用程序连接到 Geronimo 服务器

创建可以与 Geronimo EJB 应用程序对话的独立客户端

文档选项 将此页作为电子邮件发送 未显示需要 JavaScript 的文档选项 讨论 样例代码 对此页的评价 帮助我们改进这些内容 级别: 初级 Neal Sanche , Java 开发人员, Pure Technologies 2005 年 8 月 24 日 在前两篇 developerWorks 文章（参阅 参考资料） 中，作者 Neal Sanche 使用简单的电话簿应用程序来展示如何将 Apache Geronimo 应用服务器连接到数据库，以及如何使用 Geronimo 创建具有 Enterprise JavaBeans (EJB) 后端的基于 Struts 的 Web 应用程序。本文进一步使用电话簿应用程序来展示如何创建独立客户端应用程序以操作电话号码数据库。您还将学习如何配置 Geronimo 以允许来自特定客户端的安全访问。 简介 本文将展示如何开发可以与运行在 Geronimo 应用服务器内部的 EJB 应用程序通信的独立（胖）客户端。基于我的前两篇文章 ——“将数据库连接到 Geronimo 应用服务器的三种方法”（developerWorks，2005 年 6 月）和“利用 Geronimo 深入 EJB Web 应用程序” （developerWorks，2005 年 7 月）—— 本文向您展示一个连接到使用 Geronimo EJB 应用程序构建的小型电话簿数据库的 Swing 客户端。您将阅读简要的设计说明，然后阅读有关运行该应用程序所需的客户端库的信息。接下来我将介绍联系服务器并对服务器上远程无状态会话 bean 执行操作的方法。最后，您将学习如何开发、编译并运行客户端应用程序，以及如何配置服务器以允许来自网络中特定客户端的安全访问。 要最有效地利用本文，您需要熟悉用于构建 Java 桌面应用程序的 Java Swing API 以及 Apache Maven 构建系统（参阅 参考资料 以链接到 Maven Web 站点）。 回页首 设计概述 首先简要介绍一下示例应用程序设计 —— 一个描述电话簿客户端应用程序的统一建模语言 (Unified Modeling Language, UML) 部署图 —— 如 图 1 所示。客户端应用程序通过其 EJB 端口连接到 Geronimo，并与 PhoneBook Session EJB 对话以通过 PhoneBook Entry Container-Managed Persistence (CMP) 操作数据库中的数据。 图 1. 电话簿客户端部署图 Geronimo 的默认发行版对 EJB 端口有限制。仅当客户端应用程序运行在同一机器上并且通过环回地址（localhost 或 127.0.0.1） 连接时才能连接到该端口。本文稍后的 配置 Geronimo 的 EJB 端口 一节提供了有关如何让其他机器上的客户端访问服务器的详细信息。 回页首 用于连接到 Geronimo 的客户端库 要让客户端应用程序能够连接到 Geronimo 的 EJB 端口并与 EJB 层通信，客户端类路径中必须要有下列 Java 库： geronimo-spec-j2ee-1.4-rc4.jar geronimo-kernel-1.0-SNAPSHOT.jar geronimo-j2ee-1.0-SNAPSHOT.jar geronimo-security-1.0-SNAPSHOT.jar cglib-nodep-2.1.jar openejb-core-2.0-SNAPSHOT.jar 对构建结构的备注 因为对前面文章中代码的构建结构进行了一些小的修改，所以本文的代码包含了电话簿应用程序和电话簿客户端应用程序。下载 包括了有关如何使用 Maven 构建这两个应用程序的详细说明。 从源代码编译 Geronimo 时，当您使用 Maven 构建脚本来编译电话簿客户端应用程序时，这些库被放置到本地 Maven 资源库中且可供访问。您可以在 project.xml 文件的依赖关系部分中查看所有这些库位于 Maven 资源库的哪个位置。 其中一些库在客户端与服务器的通信中起着非常重要的作用。Geronimo 使用 CGLib 库来执行动态代理生成。这使得服务器动态生成远程调用服务器端组件的代码。如果在调试器中检查客户端上 InitialContext 对象的 lookup() 方法返回的一个对象，可以看到动态生成的对象的类名包括 CGLib。geronimo-spec-j2ee.jar 文件包含所有的 Sun Java 2 Platform, Enterprise Edition (J2EE) 接口和类。没有该文件，客户端将无法理解任何动态代理实例。openejb-core.jar 文件是与服务器的 EJB 端口进行对话所必需的。用于在 Geronimo 服务器中执行远程目录查询的 Java Naming and Directory Interface (JNDI) 类就在该 .jar 文件中。最后的三个 .jar 文件提供了其他支持类，比如与 Geronimo 对话的安全主体。 回页首 执行远程会话本地查询 客 户端通信部分的实现十分简单。将客户端连接到服务器时，Geronimo 与其他任何 J2EE 服务器没有任何不同，遵守健全的通过 JNDI 查询和远程方法调用 (RMI) 进行的通信标准。JNDI 查询是获得对远程对象的引用的标准访问。要通过 JNDI 进行连接，必须使用大量特定于 Geronimo 的属性来创建 InitialContext 实例，该实例用于执行查询。 清单 1 展示了有关如何创建会话的示例。 清单 1. 创建到 Geronimo 托管会话 bean 的远程会话 import java.util.Properties; import javax.naming.Context; import javax.naming.InitialContext; import javax.rmi.PortableRemoteObject; public void Connect() { String hostName = getHostName(); String port = getPort(); Properties props = new Properties(); props.setProperty("java.naming.factory.initial", "org.openejb.client.RemoteInitialContextFactory"); props.setProperty("java.naming.provider.url", hostName+":"+port); props.setProperty("java.naming.security.principal", "username"); props.setProperty("java.naming.security.credentials", "passwd"); Context ic; try { ic = new InitialContext(props); PhoneBookSessionHome sessionHome = (PhoneBookSessionHome) PortableRemoteObject.narrow( ic.lookup(PhoneBookSessionHome.JNDI_NAME), PhoneBookSessionHome.class); phoneBookSession = sessionHome.create(); } catch (Throwable ex) { ex.printStackTrace(); } finally { if (ic != null) { ic.close(); } } } 如 清单 1 所示，创建了 Properties 对象并设置了四个属性。第一个并且是最重要的属性是 java.naming.factory.initial 属性，它必须设置为 org.openejb.client.RemoteInitialContextFactory。其他属性指定提供者 URL 以及安全主体和凭证。提供者 URL 是用冒号隔开的主机名和端口。 前已提及，EJB 端口当前只接受从客户端连接到 127.0.0.1 或 localhost 的连接。默认端口是 4201。尽管如此，主机名和端口都可以进行配置。有关详细信息，请参阅 配置 Geronimo 的 EJB 端口 一节。 创建好属性之后，就可以创建并使用 InitialContext 实例了。通过将属性传递给构造函数完成这一操作。创建好实例之后，可以执行查询。清单 1 包括一行复杂的代码，该行执行查询并对结果执行 PortableRemoteObject.narrow()。对于向用户隐藏有关协议传输 —— RMI 或者可能是 Internet Inter-ORB Protocol (IIOP)—— 的详细信息，这是必需的。完成之后，远程会话就可供使用了。在 清单 1 中，该行只创建了新 PhoneBookSession，并将其存储在一个字段中以供将来使用。 具有对远程会话的引用之后，该引用可用于所有操纵电话簿数据库信息的操作。现在只需要一个应用程序来练习该远程会话。 回页首 客户端的设计和开发 现 在我们来深入研究一个小 Swing 应用程序的设计和开发，这个小应用程序用来浏览、创建、删除和修改电话簿数据库条目。我尽量将 Swing 行话减到最少，以防您比较熟悉的是另一种 GUI 技术，比如 Standard Widget Toolkit (SWT)。事实上，如果需要的话，应用程序架构已经使得将显示从应用程序内部逻辑分离出来并将其连接到另一种 GUI 技术变得非常容易。 应用程序架构如 图 2 所示，这是一个详细显示应用程序静态结构的 UML 类图。 图 2. 客户端应用程序的 UML 类图 图 2 中带绿色阴影的类是主要的应用程序类。Main 类是包含菜单和拆分窗格（其左侧是 PhoneNumberListPanel，右侧是 PhoneBookEditorPanel）的框架。该菜单还允许用户设置连接到哪个服务器的首选项，连接到服务器，并退出程序。Application 类是一个单身类（singleton class），用作应用程序的所有操作的控制器。它是惟一一个执行 EJB 操作的类，并保存对 PhoneBookSession 无状态会话 bean 的引用。 橙色的两个接口定义系统中的主要事件。每当 Application 决定电话号码列表需要更新时，就会激活 DataChangeEvent。PhoneNumberListModel 注册该事件。因为它是 PhoneNumberListPanel 中的主要数据模型列表视图，所以列表是通过模型更改来更新的。这与 Swing 应用程序的设计方法一致。 PhoneNumberListPanel 和 PhoneBookEditorPanel 类都实现 PhoneBookSelectionListener 接口并注册来自 Application 单身类的事件。当它们收到事件时，它们相应地更新当前的选择。如果是 PhoneBookEditorPanel，当前选择导致 Name 和 Number 字段由来自当前选择的电话簿条目中的数据填充。 如果希望节省编写用户接口代码的时间，通常可以在 Internet 上找到高质量的免费工具。优秀的工具有 JGoodies Forms 1.0.5 和 FormLayoutMaker，FormLayoutMaker 是一个用于可视化创建窗体的小工具（参阅 参考资料 以获得到这些工具的链接）。FormLayoutMaker 工具生成代表 JGoodies 窗体布局约束的 XML 文件。这些工具帮助我快速创建了 Phone Number 编辑面板和 Preferences 面板的窗体。 回页首 构建应用程序 编 译应用程序有两种方法。我使用 Eclipse Visual Editor (VE) 插件 1.2 版本在 Eclipse 中开发了该应用程序。它生成应用程序的大部分代码框架，但它是以一种非入侵的方式完成的（没有代码标记和不可访问的代码块），所以如果没有安装 VE 的话也应该没有问题。可以只加载项目并尝试运行它。 您可能需要设置 MAVEN_REPO 构建变量以指向本地 Maven 资源库。还需要构建与本文一起提供的源代码中包括的 Geronimo 和 PhoneBook 服务器应用程序（参阅 下载）。这是因为，要编译客户端应用程序，包含服务器应用程序中 EJB 接口的 .jar 文件必须发布到本地 Maven 资源库中。PhoneBook 的 Maven 构建脚本通过下列 Maven 构建脚本段完成该操作： 清单 2. Maven 构建脚本段 <goal name="client" prereqs="java:compile"> <ant:jar destfile="target/${pom.artifactId}-client.jar"> <fileset dir="target/classes"> <include name="**/*.class"/> </fileset> </ant:jar> <artifact:install artifact="target/${pom.artifactId}-client.jar" type="jar" project="${pom}"/> </goal> 用于构建应用程序的第二种方法就是使用 Maven。在 PhoneBook 目录中解压文件并运行 maven 命令。然后在 PhoneBookClient 目录中进行相同操作。如果一切顺利，就已经在目标子目录中创建了 UberJar —— 一个包含运行客户端所需的所有内容的 JAR 文件。 两种构建方法运行得同样好。使用 Maven 方法的优点是如果您尚未下载依赖关系，则它会自动从 ibiblio Web 站点（参阅 参考资料）上的远程 Maven 资源库中下载这些依赖关系。所以如果 Eclipse 中的依赖关系有问题，就在项目上至少运行一次 Maven 来校正缺少的库。 回页首 运行应用程序 确保 PhoneBook 服务器应用程序部署到 Geronimo 服务器中且正在运行。然后键入下列命令： java -jar phonebook-client-uber.jar 将会看到应用程序弹出，如 图 3 所示。 图 3. Geronimo 电话簿客户端应用程序 首先，从 File 菜单中选择 Connect。如果是连接到 localhost:4201 端口，则应该获得一个连接；否则，控制台窗口将会显示错误消息。可以通过选择 Edit > Preferences、更改信息并尝试重新连接来更改连接的服务器和端口。一旦连接上之后，可以通过在电话号码编辑器中键入姓名和号码并单击 Save 来创建新记录。该记录将显示在姓名列表中。通过选择条目并单击 Delete 来删除条目。通过选择条目、进行修改并单击 Save 来更改条目。 回页首 配置 Geronimo 的 EJB 端口 当 前，配置 Geronimo 的 EJB 端口的方法需要编辑 XML 文件，然后重新编译 Geronimo。Tom McQueeney 的大型 Geronimo Live blog 上的一篇短文清楚介绍了如何使用 openejb\modules\assembly\src\plan\j2ee-server-plan.xml 文件更改 Geronimo Jetty 监听端口的详细信息（参阅 参考资料 以链接到该 blog）。同一文件还包含 EJB 端口的配置信息（参阅 清单 3）。 清单 3. j2ee-server-plan.xml 文件中的代码段 <gbean name="EJBNetworkService" class="org.openejb.server.StandardServiceStackGBean"> <attribute name="name">EJB</attribute> <attribute name="port">4201</attribute> <attribute name="address">127.0.0.1</attribute> <attribute name="allowHosts">127.0.0.1</attribute> <attribute name="logOnSuccess">HOST,NAME,THREADID,USERID</attribute> <attribute name="logOnFailure">HOST,NAME</attribute> <reference name="Executor"><name>DefaultThreadPool</name></reference> <reference name="Server"> <gbean-name>openejb.server:name=EJBServer,*</gbean-name> </reference> </gbean> 您需要编辑 j2ee-server-plan.xml 文件并更改 allowHosts 属性。Geronimo 支持许多不同类型的地址。必须用下列模式之一输入逗号分隔的地址列表： 最后一格为 0 的 IP 地址。例如，192.168.10.0 允许 192.168.10 网络上的任何机器与服务器通信。 任何完全指定的 IP 地址。 分解的 IP 地址。这是一种特殊模式，允许指定地址的网络部分和以大括号扩住的主机地址列表。例如，192.168.10.{5,6,7} 允许以下三个机器访问服务器：192.168.10.5、192.168.10.6 和 192.168.10.7。 网络掩码 IP 地址。这是网络管理员熟悉的一种地址。基于精确的位模式匹配规则（超出本文范围），IP 地址与网络掩码相匹配。例如，192.168.255.255 允许 192.168.* 网络中的所有地址访问服务器。 准确的 IPv6 地址。当将来的 IP 网络到来时，Geronimo 将准备好服务，允许列出特定的 IP 地址。 网络掩码 IPv6 地址。 有 关服务器接受的特定模式的详细信息，请咨询源代码文件 —— ServiceAccessController.java —— 位于来源的 openejb\modules\core\src\java\org\openejb\server 目录中。在此将会找到与支持的每个地址类型相匹配的明确的正则表达式。 对 j2ee-server-plan.xml 文件进行修改之后，重新编译并更新服务器部署，您将具有一个专门满足您需要的服务器。（如果只想查看针对同一机器上的服务器运行的客户端，则无需这样做。默认情况下，Geronimo 被配置来完成这些操作。） 回页首 结束语 本 文提供了一个构建独立（胖）客户端的具体示例，该客户端可以与运行在 Geronimo 应用服务器内部的 EJB 应用程序进行对话。Geronimo 团队已经认真实现了健全的标准，推广用简单的 JNDI 查询方法获得与无状态会话 bean 的远程连接。如果只想让简单的应用程序运行，那么这是一个好消息，因为它只需要您编写少量代码。 按照我所介绍的模式，您能够将许多比较大的 数据库连接到与 Geronimo 服务器位于同一机器上的客户端应用程序。使用本文提供的指示，您还能够配置 Geronimo 服务器以允许从连接到您的网络或 Internet 上的其他机器访问服务器 EJB 端口。不妨尝试一下。 回页首 下载 描述 名字 大小  下载方法 Source code for the phonebook application PhonebookClient.zip 227 KB  FTP 关于下载方法的信息 获取 Adobe® Reader® 回页首 参考资料 加入本文的论坛 。(您也可以通过点击文章顶部或者底部的论坛链接参加讨论。) 您可以参阅本文在 developerWorks 全球站点上的 英文原文。 访问 Apache Geronimo 官方网站 获得文档、新闻，并下载信息。 阅读“将数据库连接到 Geronimo 应用服务器的三种方法”（developerWorks，2005 年 6 月），学习如何使用三种不同的 JDBC 数据源将数据库连接到 Geronimo。 阅读“利用 Geronimo 深入 EJB Web 应用程序 ”（developerWorks，2005 年 7 月），学习如何使用 Geronimo 开发数据库应用程序。 阅读“创建 Geronimo 客户端应用程序”（developerWorks，2005 年 6 月），深入了解用 Geronimo 生成客户端的备选方法。 访问 Apache Maven Web 站点 下载信息和文档。Maven 是用于自动化 Geronimo 应用程序部署的软件项目管理和理解工具。 访问 iBiblio repository。 在 Maven Repo Search 站点上搜索 Maven 资源库。 使用 Sing Li 的“Geronimo！第 1 部分: 支持 J2EE 1.4 引擎”（developerWorks，2005 年 5 月）作为向导熟悉 Geronimo，然后在“Geronimo！第 2 部分: 驯服 J2EE 1.4 这匹野马”（developerWorks，2005 年 5 月）中实践。 阅读 Tom McQueeney 的 Geronimo Live 博客中的“Geronimo: Changing Jetty listen port from default 8080”。 获得 JGoodies Forms 1.0.5，这是一个免费的布局管理器，用于创建外观漂亮的窗体。 获得 FormLayoutMaker rc7，这是一个拖放启用的窗体布局设计器，与 JGoodies Forms 结合使用生成 XML 文件。 下载 Gluecode Standard Edition，这是一个基于 Apache Geronimo 的免费应用服务器。 访问 developerWorks Apache Geronimo 项目区，它为 Geronimo 开发人员提供资源。 访问 developerWorks 开放源代码专区 以获得广泛的技术信息、工具和项目更新，以帮助您用开源技术进行开发，并与 IBM 产品结合使用。 在 developerWorks 开放源代码专区中浏览所有 Apache 文章 和免费的 Apache 教程。 使用 IBM 试用软件 改革您的下一个开源开发项目，该软件可以下载，也可以从 DVD 安装。 通过参与 developerWorks blogs 加入 developerWorks 社区。 回页首 关于作者 Neal Sanche 是一位最近才涉足 Microsoft® .NET 世界的 Java 开发人员，他正在克服困难脱离他原来习惯了的开发环境。他的经验包括开发多个商业 J2EE 应用程序和多个独立 Java 应用程序。在业余时间，他作曲、摄影并撰写技术文章。访问他的 Web 站点 可以看到相应的多个示例。您可以通过 neal@nsdev.org 与 Neal 联系。

public class HelloWorld extends GenericPortlet{
  protected void doView(RenderRequest request,
  RenderResponse response) throws
  PortletException, IOException {
        response.setContentType("text/html");
        response.getWriter().println("Hello Portlet");
        }
}

<portlet>
  <description>HelloWorldDescription
        </description>
    <portlet-name>HelloWorld
        </portlet-name>
    <display-name>Hello World
        </display-name>

    <portlet-class>com.test.HelloWorld
        </portlet-class>
    <expiration-cache>-1
        </expiration-cache>
        <supports>
          <mime-type>text/html</mime-type>
      <portlet-mode>VIEW
          </portlet-mode>
        </supports>
    <supported-locale>en
        </supported-locale>

        <portlet-info>
          <title>Hello World</title>
          <short-title>Hello World
          </short-title>
          <keywords>Hello,pluto</keywords>
      </portlet-info>
</portlet>

<web-app>
  <display-name>Hello World Portlet
  </display-name>
  <welcome-file-list
    <welcome-file>index.jsp
        </welcome-file>
  </welcome-file-list>
</web-app>

<servlet>
  <servlet-name>HelloWorld</servlet-name>
     <display-name>HelloWorld Wrapper</display-name>
      <description>Automated generated
      Portlet Wrapper</description>
      <servlet-class>org.apache.pluto.core.PortletServlet
      </servlet-class>
      <init-param>
         <param-name>portlet-class</param-name>
         <param-value>com.test.HelloWorld
         </param-value>
      </init-param>
      <init-param>
         <param-name>portlet-guid</param-name>
         <param-value>HelloPluto.HelloWorld
         </param-value>
      </init-param>
</servlet>

 <application id="5">
   <definition-id>HelloWorld</definition-id>
     <portlet id="1">
       <definition-id>HelloWorld.HelloWorld</definition-id>
     </portlet>
</application>

  <fragment name="p2" type="portlet">
    <property name="portlet" value="5.1"/>
</fragment>

<?xml version="1.0" encoding="UTF-8"?>
<Customers>
    <customer>
            <id>1</id>
            <gender>female</gender>
            <firstname>Jessica</firstname>
            <lastname>Lim</lastname>
            <phoneNumber>1234567</phoneNumber>
            <address>
                <primaryAddress>
                        <postalCode>350106</postalCode>
                        <addressLine1>#25-1</addressLine1>
                        <addressLine2>SHINSAYAMA 2-CHOME</addressLine2>
                </primaryAddress>
                <billingAddress>
                        <receiver>Ms Danielle</receiver>
                        <postalCode>350107</postalCode>
                        <addressLine1>#167</addressLine1>
                        <addressLine2>NORTH TOWER HARBOUR CITY</addressLine2>
                </billingAddress>
            </address>
    </customer>
    <customer>
            <id>2</id>
            <gender>male</gender>
            <firstname>David</firstname>
            <lastname>Bill</lastname>
            <phoneNumber>808182</phoneNumber>
            <address>
                <primaryAddress>
                        <postalCode>319087</postalCode>
                        <addressLine1>1033 WS St.</addressLine1>
                        <addressLine2>Tima Road</addressLine2>
                </primaryAddress>
                <billingAddress>
                        <receiver>Mr William</receiver>
                        <postalCode>672993</postalCode>
                        <addressLine1>1033 WS St.</addressLine1>
                        <addressLine2>Tima Road</addressLine2>
                </billingAddress>
            </address>
    </customer>
</Customers>

<xb:config xmlns:xb="http://xml.apache.org/xmlbeans/2004/02/xbean/config">

  <xb:namespace>
    <xb:package>sample.xmlbean</xb:package>
  </xb:namespace>

</xb:config>

       <?xml version="1.0" encoding="UTF-8"?>
       <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
                  elementFormDefault="qualified">
         <xs:element name="Customers">
           <xs:complexType>
             <xs:sequence>
               <xs:element maxOccurs="unbounded" name="customer"
                           type="customerType"/>
             </xs:sequence>
           </xs:complexType>
         </xs:element>
       <xs:complexType name="customerType">
             <xs:sequence>
               <xs:element name="id" type="xs:int"/>
               <xs:element name="gender" type="xs:string"/>
               <xs:element name="firstname" type="xs:string"/>
               <xs:element name="lastname" type="xs:string"/>
               <xs:element name="phoneNumber" type="xs:string"/>
               <xs:element name="address" type="addressType"/>
             </xs:sequence>
       </xs:complexType>
         <xs:complexType name="addressType">
             <xs:sequence>
               <xs:element name="primaryAddress" type="primaryAddressType"/>
               <xs:element name="billingAddress" type="billingAddressType"/>
             </xs:sequence>
         </xs:complexType>

         <xs:complexType name="primaryAddressType">
             <xs:sequence>
               <xs:element name="postalCode" type="xs:string"/>
               <xs:element name="addressLine1" type="xs:string"/>
               <xs:element name="addressLine2" type="xs:string"/>
             </xs:sequence>
         </xs:complexType>
         <xs:complexType name="billingAddressType">
             <xs:sequence>
                   <xs:element name="receiver" type="xs:string"/>
               <xs:element name="postalCode" type="xs:string"/>
               <xs:element name="addressLine1" type="xs:string"/>
               <xs:element name="addressLine2" type="xs:string"/>
             </xs:sequence>
         </xs:complexType>
       </xs:schema>
       

       scomp [options] [dirs]* [schemaFile.xsd]* [service.wsdl]* [config.xsdconfig]*
       

       scomp -src build\src  -out build\customerXmlBean.jar schema\customer.xsd
             -compiler C:\jdk142_04\bin\javac customer.xsdconfig
       

          CustomersDocument.java    -- 整个XML文档的Java Class映射
       CustomerType.java              -- 节点sustomer的映射
       AddressType.java                 -- 节点address的映射
       BillingAddressType.java        -- 节点billingAddress的映射
       PrimaryAddressType.java      -- 节点primaryAddress的映射
     

    package com.sample.reader;

    import java.io.File;
    
    import sample.xmlbean.*;
    import org.apache.commons.beanutils.BeanUtils;
    import org.apache.xmlbeans.XmlOptions;
    public class CustomerXMLBean {
    private String filename = null;
    
    public CustomerXMLBean(String filename) {
            super();
            this.filename = filename;
    }

    public void customerReader() {
            try {
              File xmlFile = new File(filename);
              CustomersDocument doc = CustomersDocument.Factory.parse(xmlFile);
              CustomerType[] customers = doc.getCustomers().getCustomerArray();
          
              for (int i = 0; i < customers.length; i++) {
                CustomerType customer = customers[i];
                println("Customer#" + i);
                println("Customer ID:" + customer.getId());
                println("First name:" + customer.getFirstname());
                println("Last name:" + customer.getLastname());
                println("Gender:" + customer.getGender());
                println("PhoneNumber:" + customer.getPhoneNumber());
                // Primary address
                PrimaryAddressType primaryAddress = customer.getAddress().getPrimaryAddress();
                println("PrimaryAddress:");
                println("PostalCode:" + primaryAddress.getPostalCode());
                println("AddressLine1:" + primaryAddress.getAddressLine1());
                println("AddressLine2:" + primaryAddress.getAddressLine2());
                // Billing address
                BillingAddressType billingAddress = customer.getAddress().getBillingAddress();
                println("BillingAddress:");
                println("Receiver:" + billingAddress.getReceiver());
                println("PostalCode:" + billingAddress.getPostalCode());
                println("AddressLine1:" + billingAddress.getAddressLine1());
                println("AddressLine2:" + billingAddress.getAddressLine2());
            
              }
            } catch (Exception ex) {
                    ex.printStackTrace();
            }
    }
    private void println(String str) {
          System.out.println(str);
    }
   public static void main(String[] args) {
      String filename = "F://JavaTest//Eclipse//XMLBean//xml//customers.xml";
                   
     CustomerXMLBean customerXMLBean = new CustomerXMLBean(filename);
                   customerXMLBean.customerReader();
    }

    }
    

       Customer#0
       Customer ID:1
       First name:Jessica
       Last name:Lim
       Gender:female
       PhoneNumber:1234567
       PrimaryAddress:
       PostalCode:350106
       AddressLine1:#25-1
       AddressLine2:SHINSAYAMA 2-CHOME
       BillingAddress:
       Receiver:Ms Danielle
       PostalCode:350107
       AddressLine1:#167
       AddressLine2:NORTH TOWER HARBOUR CITY

       Customer#1
       Customer ID:2
       First name:David
       Last name:Bill
       Gender:male
       PhoneNumber:808182
       PrimaryAddress:
       PostalCode:319087
       AddressLine1:1033 WS St.
       AddressLine2:Tima Road
       BillingAddress:
       Receiver:Mr William
       PostalCode:672993
       AddressLine1:1033 WS St.
       AddressLine2:Tima Road
    

    public void createCustomer() {
    try {
        // Create Document
        CustomersDocument doc = CustomersDocument.Factory.newInstance();
        // Add new customer
        CustomerType customer = doc.addNewCustomers().addNewCustomer();
        // set customer info
        customer.setId(3);
        customer.setFirstname("Jessica");
        customer.setLastname("Lim");
        customer.setGender("female");
        customer.setPhoneNumber("1234567");
        // Add new address
        AddressType address = customer.addNewAddress();
        // Add new PrimaryAddress
        PrimaryAddressType primaryAddress = address.addNewPrimaryAddress();
        primaryAddress.setPostalCode("350106");
        primaryAddress.setAddressLine1("#25-1");
        primaryAddress.setAddressLine2("SHINSAYAMA 2-CHOME");

        // Add new BillingAddress
        BillingAddressType billingAddress = address.addNewBillingAddress();
        billingAddress.setReceiver("Ms Danielle");
        billingAddress.setPostalCode("350107");
        billingAddress.setAddressLine1("#167");
        billingAddress.setAddressLine2("NORTH TOWER HARBOUR CITY");

        File xmlFile = new File(filename);
        doc.save(xmlFile);
        } catch (Exception ex) {
                ex.printStackTrace();
        }

  }
    

    public static void main(String[] args) {
    String filename = "F://JavaTest//Eclipse//XMLBean//xml//customers_new.xml";
        CustomerXMLBean customerXMLBean = new CustomerXMLBean(filename);
        customerXMLBean.createCustomer();
    }
    

    <?xml version="1.0" encoding="UTF-8"?>
    <Customers>
    <customer>
            <id>3</id>
            <gender>female</gender>
            <firstname>Jessica</firstname>
            <lastname>Lim</lastname>
            <phoneNumber>1234567</phoneNumber>
            <address>
                    <primaryAddress>
                         <postalCode>350106</postalCode>
                         <addressLine1>#25-1</addressLine1>
                                       <addressLine2>SHINSAYAMA 2-CHOME</addressLine2>
                    </primaryAddress>
                    <billingAddress>
                        <receiver>Ms Danielle</receiver>
                        <postalCode>350107</postalCode>
                       <addressLine1>#167</addressLine1>
                       <addressLine2>NORTH TOWER HARBOUR CITY</addressLine2>
                    </billingAddress>
                    </address>
            </customer>
    </Customers>
    

      public void updateCustomer(int id,String lastname) {
         try {
        File xmlFile = new File(filename);
        CustomersDocument doc = CustomersDocument.Factory.parse(xmlFile);
        CustomerType[] customers = doc.getCustomers().getCustomerArray();
      
        for (int i = 0; i < customers.length; i++) {
           CustomerType customer = customers[i];
          if(customer.getId()==id){
                customer.setLastname(lastname);
                break;
            }
        }
        doc.save(xmlFile);
         } catch (Exception ex) {
          ex.printStackTrace();
         }
           }
    

    public static void main(String[] args) {
     String filename = "F://JavaTest//Eclipse//XMLBean//xml//customers_new.xml";
                    
    CustomerXMLBean customerXMLBean = new CustomerXMLBean(filename);
                    
    customerXMLBean.updateCustomer(3,"last");
    }
    

    public void deleteCustomer(int id) {
     try {
      File xmlFile = new File(filename);
     CustomersDocument doc = CustomersDocument.Factory.parse(xmlFile);
    CustomerType[] customers = doc.getCustomers().getCustomerArray();

   for (int i = 0; i < customers.length; i++) {
        CustomerType customer = customers[i];
        if(customer.getId()==id){
                        customer.setNil() ;
                        break;
               }
   }
   doc.save(xmlFile);
   } catch (Exception ex) {
        ex.printStackTrace();
        }
   }
 

    public static void main(String[] args) {
    String filename = "F://JavaTest//Eclipse//XMLBean//xml//customers_new.xml";
                    
    CustomerXMLBean customerXMLBean = new CustomerXMLBean(filename);
                    
    customerXMLBean.deleteCustomer(3);
    }
 

Create table hotline(
country varchar2(50),
pno varchar2(50));

create or replace package PKG_HOTLINE is

type HotlineCursorType is REF CURSOR;

function getHotline return HotlineCursorType;

end;

create or replace package body PKG_HOTLINE is
function getHotline return HotlineCursorType is
hotlineCursor HotlineCursorType;
begin
open hotlineCursor for select * from hotline;
return hotlineCursor;
end;
end;

SQL> var rs refcursor;
SQL> exec :rs := PKG_HOTLINE.getHotline;
SQL> print rs;

....
public void openCursor(){
Connection conn = null;
ResultSet rs = null;
CallableStatement stmt = null;
String sql = “{? = call PKG_HOTLINE.getHotline()}“;

try{
conn = getConnection();
stmt = conn.prepareCall(sql);
stmt.registerOutParameter(1,OracleTypes.CURSOR);
stmt.execute();
rs = ((OracleCallableStatement)stmt).getCursor(1);
while(rs.next()){
String country = rs.getString(1);
String pno = rs.getString(2);
System.out.println(“country:“+country+“|pno:”+pno);
}

}catch(Exception ex){
ex.printStackTrace();
}finally{
closeConnection(conn,rs,stmt);
}

}
.....

Some of the content in this tutorial is taken from the Quartz 1.4.2 javadocs for CronTrigger.

Introduction

cron is a UNIX tool that has been around for a long time, so its scheduling capabilities are powerful and proven. The CronTrigger class is based on the scheduling capabilities of cron.

CronTrigger uses "cron expressions", which are able to create firing schedules such as: "At 8:00am every Monday through Friday" or "At 1:30am every last Friday of the month".

Cron expressions are powerful, but can be pretty confusing. This tutorial aims to take some of the mystery out of creating a cron expression, giving users a resource which they can visit before having to ask in a forum or mailing list.

Format

A cron expression is a string comprised of 6 or 7 fields separated by white space. Fields can contain any of the allowed values, along with various combinations of the allowed special characters for that field. The fields are as follows:

So cron expressions can be as simple as this: * * * * ? *
or more complex, like this: 0 0/5 14,18,3-39,52 ? JAN,MAR,SEP MON-FRI 2002-2010

Special characters

• * ("all values") - used to select all values within a field. For example, "*" in the minute field means "every minute".

• ? ("no specific value") - useful when you need to specify something in one of the two fields in which the character is allowed, but not the other. For example, if I want my trigger to fire on a particular day of the month (say, the 10th), but don't care what day of the week that happens to be, I would put "10" in the day-of-month field, and "?" in the day-of-week field. See the examples below for clarification.

• - - used to specify ranges. For example, "10-12" in the hour field means "the hours 10, 11 and 12".

• , - used to specify additional values. For example, "MON,WED,FRI" in the day-of-week field means "the days Monday, Wednesday, and Friday".

• / - used to specify increments. For example, "0/15" in the seconds field means "the seconds 0, 15, 30, and 45". And "5/15" in the seconds field means "the seconds 5, 20, 35, and 50". You can also specify '/' after the '*' character - in this case '*' is equivalent to having '0' before the '/'. '1/3' in the day-of-month field means "fire every 3 days starting on the first day of the month".

• L ("last") - has different meaning in each of the two fields in which it is allowed. For example, the value "L" in the day-of-month field means "the last day of the month" - day 31 for January, day 28 for February on non-leap years. If used in the day-of-week field by itself, it simply means "7" or "SAT". But if used in the day-of-week field after another value, it means "the last xxx day of the month" - for example "6L" means "the last friday of the month". When using the 'L' option, it is important not to specify lists, or ranges of values, as you'll get confusing results.

• W ("weekday") - used to specify the weekday (Monday-Friday) nearest the given day. As an example, if you were to specify "15W" as the value for the day-of-month field, the meaning is: "the nearest weekday to the 15th of the month". So if the 15th is a Saturday, the trigger will fire on Friday the 14th. If the 15th is a Sunday, the trigger will fire on Monday the 16th. If the 15th is a Tuesday, then it will fire on Tuesday the 15th. However if you specify "1W" as the value for day-of-month, and the 1st is a Saturday, the trigger will fire on Monday the 3rd, as it will not 'jump' over the boundary of a month's days. The 'W' character can only be specified when the day-of-month is a single day, not a range or list of days.

The 'L' and 'W' characters can also be combined in the day-of-month field to yield 'LW', which translates to "last weekday of the month".

• # - used to specify "the nth" XXX day of the month. For example, the value of "6#3" in the day-of-week field means "the third Friday of the month" (day 6 = Friday and "#3" = the 3rd one in the month). Other examples: "2#1" = the first Monday of the month and "4#5" = the fifth Wednesday of the month. Note that if you specify "#5" and there is not 5 of the given day-of-week in the month, then no firing will occur that month.

• C ("calendar") - this means values are calculated against the associated calendar, if any. If no calendar is associated, then it is equivalent to having an all-inclusive calendar. A value of "5C" in the day-of-month field means "the first day included by the calendar on or after the 5th". A value of "1C" in the day-of-week field means "the first day included by the calendar on or after Sunday".

The legal characters and the names of months and days of the week are not case sensitive. MON is the same as mon.

Examples

Here are some full examples:

Pay attention to the effects of '?' and '*' in the day-of-week and day-of-month fields!

public void execute(JobExecutionContext context) 
     throws JobExecutionException;

#===============================================================
# Configure Main Scheduler Properties  
#===============================================================

org.quartz.scheduler.instanceName = QuartzScheduler
org.quartz.scheduler.instanceId = AUTO

#===============================================================
# Configure ThreadPool  
#===============================================================

org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount =  5
org.quartz.threadPool.threadPriority = 5

#===============================================================
# Configure JobStore  
#===============================================================

org.quartz.jobStore.misfireThreshold = 60000
org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore

public class ScanFTPSiteJob implements Job {
    private static Log logger = LogFactory.getLog(ScanFTPSiteJob.class);

    /*
     * Called the scheduler framework at the right time
     */
    public void execute(JobExecutionContext context)
            throws JobExecutionException {

        JobDataMap jobDataMap = context.getJobDataMap();

        try {
            // Check the ftp site for files
            File[] files = JobUtil.checkForFiles(jobDataMap);

            JobUtil.sendEmail(jobDataMap, files);
        } catch (Exception ex) {
            throw new JobExecutionException(ex.getMessage());
        }
    }
}

public class MyQuartzServer {

    public static void main(String[] args) {
        MyQuartzServer server = new MyQuartzServer();

        try {
            server.startScheduler();
        } catch (SchedulerException ex) {
            ex.printStackTrace();
        }
    }

    protected void startScheduler() throws SchedulerException {

        // Use the factory to create a Scheduler instance
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

        // JobDetail holds the definition for Jobs
        JobDetail jobDetail = 
new JobDetail("ScanFTPJob", Scheduler.DEFAULT_GROUP,
                ScanFTPSiteJob.class);

// Store job parameters to be used within execute()
jobDetail.getJobDataMap().put(
"FTP_HOST", 
"\\home\\cavaness\\inbound");

        // Other neccessary Job parameters here

        // Create a Trigger that fires every 60 seconds
        Trigger trigger = TriggerUtils.makeSecondlyTrigger(60);
        
        // Setup the Job and Trigger with the Scheduler
        scheduler.scheduleJob(jobDetail, trigger );
        
        // Start the Scheduler running
        scheduler.start();
    }
}

<?xml version='1.0' encoding='utf-8'?>
<quartz>
    <job>
        <job-detail>
            <name>ScanFTPSiteJob</name>
            <group>DEFAULT</group>
            <description>
                A job that scans an ftp site for files
            </description>
            <job-class>ScanFTPSiteJob</job-class>

            <job-data-map allows-transient-data="true">
                <entry>
                    <key>FTP_HOST</key>
                    <value>\home\cavaness\inbound</value>
                </entry>
                
                <!--  Other neccessary Job parameters here -->

            </job-data-map>
        </job-detail>

        <trigger>
            <simple>
                <name>ScanFTPSiteJobTrigger</name>
                <group>DEFAULT</group>
                <job-name>ScanFTPSiteJob</job-name>
                <job-group>DEFAULT</job-group>
                <start-time>2005-09-11 6:10:00 PM</start-time>
                <!-- repeat indefinitely every 60 seconds -->
                <repeat-count>-1</repeat-count>
                <repeat-interval>60000</repeat-interval>
            </simple>
        </trigger>

    </job>
</quartz>

方法一:

调用Windows的DOS命令,从输出结果中读取MAC地址:

public static String getMACAddress() {

String address = "";
String os = System.getProperty("os.name");
if ( os != null && os.startsWith("Windows")) {
try {
String command = "cmd.exe /c ipconfig /all";
Process p = Runtime.getRuntime().exec(command);
BufferedReader br =
new BufferedReader(
new InputStreamReader(p.getInputStream()));
String line;
while ((line = br.readLine()) != null) {
if (line.indexOf("Physical Address") > 0) {
int index = line.indexOf(":");
index += 2;
address = line.substring(index);
break;
}
}
br.close();
return address.trim();
}
catch (IOException e) { }
}
return address;
}

We can replace the "ipconfig" to "ping x.x.x.x" and "arp -a"...We can get the mac list...haha!!

缺点:只能取得服务器端MAC地址.如果要取得客户端的MAC地址,需用Applet.只针对MS-WIN系统.

方法二:

可以用JS或vbscript来调用WMI接口来获取Client端的MAC地址.

忘了附上原文的出处了：
How to get IP address of the browser when its operating behind a proxy/firewall? (applets...activex....??)
http://www.faqts.com/knowledge_base/view.phtml/aid/9005/fid/125

关于WMI的详细信息可以参看MSDN:
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/wmisdk/wmi/wmi_tasks_for_scripts_and_applications.asp

平心而论，WMI的很强大的。原先需要动用重量级编程工具才能做到的事，现在用js/vbscript就可以做了。

获取多块网卡的MAC地址:

if(objObject.MACAddress != null && objObject.MACAddress != "undefined"){
                         MACAddr = objObject.MACAddress;
                         alert( MACAddr );
                   }

缺点:需要ActiveX支持.对MS-WIN系统有效.

方法三:

想137口发送UDP查询:

WINDOWS平台的客户端(当获取时它转换为服务端角色),NETBIOS协议在137口上,我们只要向它的137口发送UDP查询,获取它的返回值就可以获取到它所有的网卡地址.

以上内容来自dev2dev的讨论帖:

http://dev2dev.bea.com.cn/bbs/thread.jspa?forumID=121&threadID=12941&tstart=0