ThreadLocal是什么

早在JDK 1.2的版本中就提供java.lang.ThreadLocal，ThreadLocal为解决多线程程序的并发问题提供了一种新的思路。使用这个工具类可以很简洁地编写出优美的多线程程序。

ThreadLocal很容易让人望文生义，想当然地认为是一个“本地线程”。其实，ThreadLocal并不是一个Thread，而是Thread的局部变量，也许把它命名为ThreadLocalVariable更容易让人理解一些。

当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。

从线程的角度看，目标变量就象是线程的本地变量，这也是类名中“Local”所要表达的意思。

线程局部变量并不是Java的新发明，很多语言（如IBM IBM XL FORTRAN）在语法层面就提供线程局部变量。在Java中没有提供在语言级支持，而是变相地通过ThreadLocal的类提供支持。

所以，在Java中编写线程局部变量的代码相对来说要笨拙一些，因此造成线程局部变量没有在Java开发者中得到很好的普及。

ThreadLocal的接口方法

ThreadLocal类接口很简单，只有4个方法，我们先来了解一下：

• void set(Object value)

设置当前线程的线程局部变量的值。

• public Object get()

该方法返回当前线程所对应的线程局部变量。

• public void remove()

将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是JDK 5.0新增的方法。需要指出的是，当线程结束后，对应该线程的局部变量将自动被垃圾回收，所以显式调用该方法清除线程的局部变量并不是必须的操作，但它可以加快内存回收的速度。

• protected Object initialValue()

返回该线程局部变量的初始值，该方法是一个protected的方法，显然是为了让子类覆盖而设计的。这个方法是一个延迟调用方法，在线程第1次调用get()或set(Object)时才执行，并且仅执行1次。ThreadLocal中的缺省实现直接返回一个null。

值得一提的是，在JDK5.0中，ThreadLocal已经支持泛型，该类的类名已经变为ThreadLocal<T>。API方法 也相应进行了调整，新版本的API方法分别是void set(T value)、T get()以及T initialValue()。

ThreadLocal是如何做到为每一个线程维护变量的副本的呢？其实实现的思路很简单：在ThreadLocal类中有一个Map，用于存储每一个线程的变量副本，Map中元素的键为线程对象，而值对应线程的变量副本。我们自己就可以提供一个简单的实现版本：

代码清单1 SimpleThreadLocal

public class SimpleThreadLocal {

private Map valueMap = Collections.synchronizedMap(new HashMap());

public void set(Object newValue) {

valueMap.put(Thread.currentThread(), newValue);①键为线程对象，值为本线程的变量副本

}

public Object get() {

Thread currentThread = Thread.currentThread();

Object o = valueMap.get(currentThread);②返回本线程对应的变量

if (o == null && !valueMap.containsKey(currentThread)) {③如果在Map中不存在，放到Map

中保存起来。

o = initialValue();

valueMap.put(currentThread, o);

}

return o;

}

public void remove() {

valueMap.remove(Thread.currentThread());

}

public Object initialValue() {

return null;

}

}

虽然代码清单9‑3这个ThreadLocal实现版本显得比较幼稚，但它和JDK所提供的ThreadLocal类在实现思路上是相近的。

一个TheadLocal实例

下面，我们通过一个具体的实例了解一下ThreadLocal的具体使用方法。

代码清单2 SequenceNumber

package com.baobaotao.basic;

public class SequenceNumber {

①通过匿名内部类覆盖ThreadLocal的initialValue()方法，指定初始值

private static ThreadLocal<Integer> seqNum = new ThreadLocal<Integer>(){

public Integer initialValue(){

return 0;

}

};

②获取下一个序列值

public int getNextNum(){

seqNum.set(seqNum.get()+1);

return seqNum.get();

}

public static void main(String[] args)

{

SequenceNumber sn = new SequenceNumber();

③ 3个线程共享sn，各自产生序列号

TestClient t1 = new TestClient(sn);

TestClient t2 = new TestClient(sn);

TestClient t3 = new TestClient(sn);

t1.start();

t2.start();

t3.start();

}

private static class TestClient extends Thread

{

private SequenceNumber sn;

public TestClient(SequenceNumber sn) {

this.sn = sn;

}

public void run()

{

for (int i = 0; i < 3; i++) {④每个线程打出3个序列值

System.out.println("thread["+Thread.currentThread().getName()+

"] sn["+sn.getNextNum()+"]");

}

}

}

}

通常我们通过匿名内部类的方式定义ThreadLocal的子类，提供初始的变量值，如例子中①处所示。TestClient线程产生一组序列号， 在③处，我们生成3个TestClient，它们共享同一个SequenceNumber实例。运行以上代码，在控制台上输出以下的结果：

thread[Thread-2] sn[1]

thread[Thread-0] sn[1]

thread[Thread-1] sn[1]

thread[Thread-2] sn[2]

thread[Thread-0] sn[2]

thread[Thread-1] sn[2]

thread[Thread-2] sn[3]

thread[Thread-0] sn[3]

thread[Thread-1] sn[3]

考察输出的结果信息，我们发现每个线程所产生的序号虽然都共享同一个SequenceNumber实例，但它们并没有发生相互干扰的情况，而是各自产生独立的序列号，这是因为我们通过ThreadLocal为每一个线程提供了单独的副本。

Thread同步机制的比较

ThreadLocal和线程同步机制相比有什么优势呢？ThreadLocal和线程同步机制都是为了解决多线程中相同变量的访问冲突问题。

在同步机制中，通过对象的锁机制保证同一时间只有一个线程访问变量。这时该变量是多个线程共享的，使用同步机制要求程序慎密地分析什么时候对变量进行读写，什么时候需要锁定某个对象，什么时候释放对象锁等繁杂的问题，程序设计和编写难度相对较大。

而ThreadLocal则从另一个角度来解决多线程的并发访问。ThreadLocal会为每一个线程提供一个独立的变量副本，从而隔离了多个线 程对数据的访问冲突。因为每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象，在编 写多线程代码时，可以把不安全的变量封装进ThreadLocal。

由于ThreadLocal中可以持有任何类型的对象，低版本JDK所提供的get()返回的是Object对象，需要强制类型转换。但JDK 5.0通过泛型很好的解决了这个问题，在一定程度地简化ThreadLocal的使用，代码清单 9 2就使用了JDK 5.0新的ThreadLocal<T>版本。

概括起来说，对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。

Spring使用ThreadLocal解决线程安全问题

我们知道在一般情况下，只有无状态的Bean才可以在多线程环境下共享，在Spring中，绝大部分Bean都可以声明为singleton作用 域。就是因为Spring对一些Bean（如RequestContextHolder、 TransactionSynchronizationManager、LocaleContextHolder等）中非线程安全状态采用 ThreadLocal进行处理，让它们也成为线程安全的状态，因为有状态的Bean就可以在多线程中共享了。

一般的Web应用划分为展现层、服务层和持久层三个层次，在不同的层中编写对应的逻辑，下层通过接口向上层开放功能调用。在一般情况下，从接收请求到返回响应所经过的所有程序调用都同属于一个线程，如图9‑2所示：

图1同一线程贯通三层

这样你就可以根据需要，将一些非线程安全的变量以ThreadLocal存放，在同一次请求响应的调用线程中，所有关联的对象引用到的都是同一个变量。

下面的实例能够体现Spring对有状态Bean的改造思路：

代码清单3 TopicDao：非线程安全

public class TopicDao {

private Connection conn;①一个非线程安全的变量

public void addTopic(){

Statement stat = conn.createStatement();②引用非线程安全变量

…

}

}

由于①处的conn是成员变量，因为addTopic()方法是非线程安全的，必须在使用时创建一个新TopicDao实例（非singleton）。下面使用ThreadLocal对conn这个非线程安全的“状态”进行改造：

代码清单4 TopicDao：线程安全

import java.sql.Connection;

import java.sql.Statement;

public class TopicDao {

①使用ThreadLocal保存Connection变量

private static ThreadLocal<Connection> connThreadLocal = new ThreadLocal<Connection>();

public static Connection getConnection(){

②如果connThreadLocal没有本线程对应的Connection创建一个新的Connection，

并将其保存到线程本地变量中。

if (connThreadLocal.get() == null) {

Connection conn = ConnectionManager.getConnection();

connThreadLocal.set(conn);

return conn;

}else{

return connThreadLocal.get();③直接返回线程本地变量

}

}

public void addTopic() {

④从ThreadLocal中获取线程对应的Connection

Statement stat = getConnection().createStatement();

}

}

不同的线程在使用TopicDao时，先判断connThreadLocal.get()是否是null，如果是null，则说明当前线程还没有对 应的Connection对象，这时创建一个Connection对象并添加到本地线程变量中；如果不为null，则说明当前的线程已经拥有了 Connection对象，直接使用就可以了。这样，就保证了不同的线程使用线程相关的Connection，而不会使用其它线程的 Connection。因此，这个TopicDao就可以做到singleton共享了。

当然，这个例子本身很粗糙，将Connection的ThreadLocal直接放在DAO只能做到本DAO的多个方法共享Connection时 不发生线程安全问题，但无法和其它DAO共用同一个Connection，要做到同一事务多DAO共享同一Connection，必须在一个共同的外部类 使用ThreadLocal保存Connection。

小结

ThreadLocal是解决线程安全问题一个很好的思路，它通过为每个线程提供一个独立的变量副本解决了变量并发访问的冲突问题。在很多情况 下，ThreadLocal比直接使用synchronized同步机制解决线程安全问题更简单，更方便，且结果程序拥有更高的并发性。

前几天跟着写了一个简单的例子.
觉得Drools的配置也没有什么.
今天在运行house的例子的时候, 无论怎么样, 总是异常: 没有定义的SMF.
显然没有找到我定义的drools.config文件.
官方网站上是这样写地:
String droolsConfigProp = System.getProperty( "drools.conf" );

if ( droolsConfigProp != null )
{
    loadConfig( droolsConfigProp );
}

ClassLoader cl = Thread.currentThread( ).getContextClassLoader( ); if ( cl == null )
{
    cl = getClass( ).getClassLoader( );
}

Enumeration configUrls = cl.getResources( "META-INF/drools.conf" );

if ( !configUrls.hasMoreElements( ) )
{
    cl = getClass( ).getClassLoader( );
    configUrls = cl.getResources( "META-INF/drools.conf" );
}

if ( !configUrls.hasMoreElements( ) )
{
    cl = ClassLoader.getSystemClassLoader( );
    configUrls = cl.getResources( "META-INF/drools.conf" );
}

this.classLoader = cl;
while ( configUrls.hasMoreElements( ) )
{
    URL configUrl = (URL) configUrls.nextElement( );
    loadConfig( configUrl );
}

一般情况下, 只显式引用:

• drools-all-2.0.jar
• antlr-2.7.5.jar
• xercesImpl-2.6.2.jar

就可以了.当然ClassPath下也要用一些其他的jar.
下载位置: http://dist.codehaus.org/drools/distributions/drools-2.0-bin-withdeps.zip

如果, 在DRL文件中定义了Java Function, 这时候就要显式的引用:

• janino-2.3.2.jar

这时候, 引擎是需要janino把DRL中的java function描述转换成可执行的二进制代码(?)的.

Drools and Mandarax

Open Source Rule Engines Written In Java

• Drools The drools engine uses a modified form of the Rete algorithm called the Rete-OO algorithm. Internally it operates using the same concepts and methods as Forgy's original but adds some node types required for seemless integration with an object-oriented language.
• OFBiz Rule Engine Backward chaining is supported. Original code base from "Building Parsers in Java" by Steven John Metsker.
• Mandarax Based on backward reasoning. The easy integration of all kinds of data sources. E.g., database records can be easily integrated as sets of facts and reflection is used in order to integrate functionality available in the object model.
• Algernon Efficient and concise KB traversal and retrieval. Straightforward access to ontology classes and instances. Supports both forward and backward chaining.
• TyRuBa TyRuBa supports higher order logic programming: variables and compound terms are allowed everywhere in queries and rules, also in the position of a functor- or predicate-name. TyRuBa speeds up execution by making specialized copies of the rule-base for each query in the program. It does so incrementally while executing a logic program and builds an index for fast access to rules and facts in the rule base, tuned to the program that is running. The indexing techniques works also for higher-order logic. TyRuBa does 'tabling' of query results.
• JTP Java Theorem Prover is based on a very simple and general reasoning architecture. The modular character of the architecture makes it easy to extend the system by adding new reasoning modules (reasoners), or by customizing or rearranging existing ones.
• JEOPS JEOPS adds forward chaining, first-order production rules to Java through a set of classes designed to provide this language with some kind of declarative programming.
• InfoSapient Semantics of business rules expressed using fuzzy logic.
• JShop Simple Hierarchical Ordered Planner (SHOP) written in Java.
• RDFExpert RDF-driven expert system shell. The RDFExpert software uses Brian McBride's JENA API and parser. A simple expert system shell that uses RDF for all of its input: knowledge base, inference rules and elements of the resolution strategy employed. It supports forward and backward chaining.
• Jena 2 - Jena is a Java framework for writing Semantic Web applications. Jena2 has a reasoner subsystem which includes a generic rule based inference engine together with configured rule sets for RDFS and for the OWL/Lite subset of OWL Full. These reasoners can be used to construct inference models which show the RDF statements entailed by the data being reasoned over. The subsystem is designed to be extensible so that it should be possible to plug a range of external reasoners into Jena, though worked examples of doing so are left to a future release.
• JLisa - JLisa is a powerful framework for building business rules accessible to Java and it is compatible with JSR-94. JLisa is more powerful than Clips because it has the expanded benefit of having all the features from common lisp available. These features are essential for multi-paradigm software development
• Euler - Euler is a backward-chaining reasoner enhanced with Euler path detection and will tell you whether a given set of facts and rules supports a given conclusion. Things are described in N3.
• JLog - JLog is an implementation of a Prolog interpreter, written in Java. It includes built-in source editor, query panels, online help, animation primitives, and a GUI debugger.
• Pellet OWL Reasoner - Pellet is an open-source Java based OWL DL reasoner. It can be used in conjunction with either Jena or OWL API libraries. Pellet API provides functionalities to see the species validation, check consistency of ontologies, classify the taxonomy, check entailments and answer a subset of RDQL queries (known as ABox queries in DL terminology). Pellet is an OWL DL reasoner based on the tableaux algorithms developed for expressive Description Logics.
• Prova - Prova is derived from Mandarax Java-based inference system developed by Jens Dietrich. Prova extends Mandarax by providing a proper language syntax, native syntax integration with Java, and agent messaging and reaction rules. The development of this language was supported by the grant provided within the EU project GeneStream. In the project, the language is used as a rules-based backbone for distributed web applications in biomedical data integration.

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)

1. document.form.item 问题
    (1)现有问题：
        现有代码中存在许多 document.formName.item("itemName") 这样的语句，不能在 MF 下运行
    (2)解决方法：
        改用 document.formName.elements["elementName"]
    (3)其它
        参见 2

2. 集合类对象问题
    (1)现有问题：
        现有代码中许多集合类对象取用时使用 ()，IE 能接受，MF 不能。
    (2)解决方法：
        改用 [] 作为下标运算。如：document.forms("formName") 改为 document.forms["formName"]。
        又如：document.getElementsByName("inputName")(1) 改为 document.getElementsByName("inputName")[1]
    (3)其它

3. window.event
    (1)现有问题：
        使用 window.event 无法在 MF 上运行
    (2)解决方法：
        MF 的 event 只能在事件发生的现场使用，此问题暂无法解决。可以这样变通：
        原代码(可在IE中运行)：
            <input type="button" name="someButton" value="提交" onclick="javascript:gotoSubmit()"/>
            ...
            <script language="javascript">
                function gotoSubmit() {
                    ...
                    alert(window.event);    // use window.event
                    ...
                }
            </script>

        新代码(可在IE和MF中运行)：
            <input type="button" name="someButton" value="提交" onclick="javascript:gotoSubmit(event)"/>
            ...
            <script language="javascript">
                function gotoSubmit(evt) {
                    evt = evt ? evt : (window.event ? window.event : null);
                    ...
                    alert(evt);             // use evt
                    ...
                }
            </script>
        此外，如果新代码中第一行不改，与老代码一样的话(即 gotoSubmit 调用没有给参数)，则仍然只能在IE中运行，但不会出错。所以，这种方案 tpl 部分仍与老代码兼容。

4. HTML 对象的 id 作为对象名的问题
    (1)现有问题
        在 IE 中，HTML 对象的 ID 可以作为 document 的下属对象变量名直接使用。在 MF 中不能。
    (2)解决方法
        用 getElementById("idName") 代替 idName 作为对象变量使用。

5. 用idName字符串取得对象的问题
    (1)现有问题
        在IE中，利用 eval(idName) 可以取得 id 为 idName 的 HTML 对象，在MF 中不能。
    (2)解决方法
        用 getElementById(idName) 代替 eval(idName)。

6. 变量名与某 HTML 对象 id 相同的问题
    (1)现有问题
        在 MF 中，因为对象 id 不作为 HTML 对象的名称，所以可以使用与 HTML 对象 id 相同的变量名，IE 中不能。
    (2)解决方法
        在声明变量时，一律加上 var ，以避免歧义，这样在 IE 中亦可正常运行。
        此外，最好不要取与 HTML 对象 id 相同的变量名，以减少错误。
    (3)其它
        参见 问题4

7. event.x 与 event.y 问题
    (1)现有问题
        在IE 中，event 对象有 x, y 属性，MF中没有。
    (2)解决方法
        在MF中，与event.x 等效的是 event.pageX。但event.pageX IE中没有。
        故采用 event.clientX 代替 event.x。在IE 中也有这个变量。
        event.clientX 与 event.pageX 有微妙的差别（当整个页面有滚动条的时候），不过大多数时候是等效的。

        如果要完全一样，可以稍麻烦些：
        mX = event.x ? event.x : event.pageX;
        然后用 mX 代替 event.x
    (3)其它
        event.layerX 在 IE 与 MF 中都有，具体意义有无差别尚未试验。

8. 关于frame
   (1)现有问题
         在 IE中 可以用window.testFrame取得该frame，mf中不行
   (2)解决方法
         在frame的使用方面mf和ie的最主要的区别是：
如果在frame标签中书写了以下属性：
<frame src="xx.htm" id="frameId" name="frameName" />
那么ie可以通过id或者name访问这个frame对应的window对象
而mf只可以通过name来访问这个frame对应的window对象
例如如果上述frame标签写在最上层的window里面的htm里面，那么可以这样访问
ie： window.top.frameId或者window.top.frameName来访问这个window对象
mf： 只能这样window.top.frameName来访问这个window对象

另外，在mf和ie中都可以使用window.top.document.getElementById("frameId")来访问frame标签
并且可以通过window.top.document.getElementById("testFrame").src = 'xx.htm'来切换frame的内容
也都可以通过window.top.frameName.location = 'xx.htm'来切换frame的内容
关于frame和window的描述可以参见bbs的‘window与frame’文章
以及/test/js/test_frame/目录下面的测试
----adun 2004.12.09修改

9. 在mf中，自己定义的属性必须getAttribute()取得
10.在mf中没有  parentElement parement.children  而用
               parentNode parentNode.childNodes
   childNodes的下标的含义在IE和MF中不同，MF使用DOM规范，childNodes中会插入空白文本节点。
  一般可以通过node.getElementsByTagName()来回避这个问题。
   当html中节点缺失时，IE和MF对parentNode的解释不同，例如
   <form>
   <table>
        <input/>
   </table>
   </form>
   MF中input.parentNode的值为form, 而IE中input.parentNode的值为空节点

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

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

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

13. url encoding
在js中如果书写url就直接写&不要写&amp;例如var url = 'xx.jsp?objectName=xx&amp;objectEvent=xxx';
frm.action = url那么很有可能url不会被正常显示以至于参数没有正确的传到服务器
一般会服务器报错参数没有找到
当然如果是在tpl中例外，因为tpl中符合xml规范，要求&书写为&amp;
一般MF无法识别js中的&amp;

14. nodeName 和 tagName 问题
  (1)现有问题：
     在MF中，所有节点均有 nodeName 值，但 textNode 没有 tagName 值。在 IE 中，nodeName 的使用好象
     有问题（具体情况没有测试，但我的IE已经死了好几次）。
  (2)解决方法：
     使用 tagName，但应检测其是否为空。

15. 元素属性
   IE下 input.type属性为只读，但是MF下可以修改

这里说说我的经历吧。大学前以及大学前面三年的经历就不说了，因为大学前的高中就是好好学习，大学前三年就是混过来的。

    我上的学校还算可以，虽然不是北大清华这样第一流名牌大学，但至少也算中国的第二流名牌大学了。大学中前面三年都陪伴着游戏过去，所学到的只是些计算机基 础知识。到大四后我突然发现就业的问题就在眼前，而自己似乎什么也不会，于是开始看书。最一开始重点看的是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有了比 较好的了解的开发人员我强烈推荐看这本书。看了这本书以后我都在回想以前设计的一些框架，一些模块，觉得自己有很多地方当时设计的时候觉得很精巧，不过却 属于弄巧成拙，加大了模块的耦合性，所以在修改的时候比较难于下手。

<bean id="dataSource" 
   class="org.springframework.jndi.JndiObjectFactoryBean">
     <property name="jndiName">
        <value>java:comp/env/jdbc/petclinic</value>
     </property>
</bean>

<bean id="transactionManager" 
   class="org.springframework.transaction.jta.JtaTransactionManager"/>

<bean id="clinicTarget" 
   class="org.springframework.samples.petclinic.jdbc.JdbcClinic">
    <property name="dataSource"><ref bean="dataSource"/></property>
</bean>

<bean id="clinic" 
   class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
    <property name="transactionManager"><ref bean="transactionManager"/></property>
    <property name="target"><ref bean="clinicTarget"/></property>
    <property name="transactionAttributes">
        <props>
            <prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>
            <prop key="store*">PROPAGATION_REQUIRED</prop>
        </props>
    </property>
</bean>

public interface Clinic {
    Pet loadPet(int id);
    void storePet(Pet pet);
    ...
}

public class JdbcClinic implements Clinic {

    private DataSource dataSource;

    public void setDataSource(DataSource dataSource) {
      this.dataSource = dataSource;
    }

    public Pet loadPet(int id) {
      try {
          Connection con = this.dataSource.getConnection();
          ...
      }
      catch (SQLException ex) {
        ...
      }
    }

    public void storePet(Pet pet) {
      try {
          Connection con = this.dataSource.getConnection();
          ...
      }
      catch (SQLException ex) {
        ...
      }
    }

    ...
}

<prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="store*">PROPAGATION_REQUIRED</prop>

WebApplicationContext ctx = 
   WebApplicationContexUtils.getWebApplicationContext(servletContext);
Clinic clinic = (Clinic) ctx.getBean("clinic);

Pet pet = new Pet();
pet.setName("my new cat");

clinic.storePet(pet);

<prop key="load*">PROPAGATION_REQUIRED,readOnly,-PetClinicException</prop>
<prop key="store*">PROPAGATION_REQUIRED,-PetClinicException</prop>

<bean id="transactionManager" 
   class="org.springframework.transaction.jta.JtaTransactionManager">
     <property name="transactionManagerName">
        <value>vendorSpecificJndiLocation</value>
     </property>
</bean>

物流软件厂商出路何在？

“几乎没有一个物流企业是赢利的”、“几乎没有一家物流软件提供商是赚钱的”、“几乎没有一个物流信息化项目是成功的”，这样的判断背后的事实是，物流软件厂商的日子比黄莲还苦。

“大家都知道做ERP苦，我们做物流软件的比ERP更苦。”坐在我对面的某物流软件公司总经理臧先生一脸无奈。三年前，他从一家国外的ERP公司跳槽到此，因为那时候他对“物流信息化高潮已经来临”深信不疑。

“现在，物流软件对于我们集团来说就是一块鸡肋，食之无味，弃之可惜”。事实上，从2004年起，业界就曾风传该公司将被卖掉。熬到2005年年底，情况并没有好转而业绩更糟。“年后我得另谋生路了，”臧先生说，“但物流软件公司，打死我也不去。”

比做ERP还苦

关于物流信息化有几段“名言”：“几乎没有一个物流企业是赢利的”、“几乎没有一家物流软件提供商是赚钱的”、“几乎没有一个物流信息化项目是成功的。”这样的判断就如同“中国ERP实施成功率为零”一样的偏颇。但是其背后的事实是，“物流软件厂商的日子比黄莲还苦”。

随便拿起一个物流软件公司的宣传册，烟草、医药、石油、化工、快速消费品等行业巨头的成功案例都赫然在目。“这些 动辄上百万元，甚至上千万元的项目其实没有几个是赚钱的。”另一家物流软件公司的总经理陈先生对记者说：“就好比夏奈尔每年的时装发布会，只是为了一个品 牌形象，实在不指望它能赚钱。大型物流信息化项目基本上就是赔本赚吆喝。”

也有人甘愿“赔本赚吆喝”，上海博科公司营销副总经理周龙就认为大型项目就算不赚钱也是“值”的。“我们所做的 诸如中国石油这样的大型的物流信息化项目，哪怕利润不是很高，我们也要坚持做，不但坚持做还要让客户满意，这对我们品牌宣传很重要。”周龙认为，博科在国 内物流信息化领域的地位日渐强势，与这些大项目的实施紧密相关。

但是更多的厂商是“赔了夫人又折兵”，被无休止的“烂尾工程”拖入泥沼。臧先生所在的物流公司在2004年希望 能上演“绝地反击”，为了项目和销售额几乎到了不择手段的地步，在竞标中时常被称为“搅屎棍”，以超低价格接连接了四个大的项目，但是灾难也就接踵而至， 项目实施无休无止，甚至有客户难以忍受该公司的“折磨”而要和厂商对簿公堂。

之所以要这样冒险一搏的原因还是恶劣的竞争环境使然。“泥沙俱下，鱼龙混杂”是一位业内人士对目前物流软件市场 的看法。由于2002年前后，业界爆炒物流信息化高潮来临，引来无数的投机者和投资者，物流软件提供商的数量急剧增多，据中国物流信息化中心初步统计，我 国物流软件厂商有500多家，此外还有一些知名的国外物流商、IT公司和咨询公司也在中国的物流软件市场中淘金。

北京海淀东北旺一家物流公司的老板金先生对记者说，今年至少有30家软件公司找过他，报价最低5万元，最高的是 300万元。“说实话，我被他们越搞越糊涂了，不知道究竟该相信谁。也不知道他们说的是不是真话。”事实上，据业内人士透露，声称做物流信息软件的公司中 70%到80%的企业都属于“混水摸鱼”，他们就是在传统仓储管理软件或者运输管理软件的基础上加以修改，然后就宣称这是一套物流信息系统。“懂物流的企 业不多，却有更多的企业在搅局。”

三个错位

业内分析人士认为，造成目前物流软件厂商集体陷入困境的原因是“三个错位”。

AMT企业资源研究中心资深顾问赵杨说：“对物流信息化的爆炒而带来的恶性竞争是物流软件厂商陷入困境的主要原因。”而从另外一个角度看，其实就是市场需求滞长而厂商预期过高之间的错位使然。

据中国物流信息中心预测，2004～2006年，每年物流软件市场的总体规模将维持在20亿～35亿元人民币之 间，年增长率大约为5%左右。但是在此之前，大多数的物流软件厂商都对这个市场过于乐观，使得市场竞争者蜂拥而至。像用友金蝶这样的专业ERP公司都成立 物流部门做企业物流业务，国外巨头如i2、SSA、曼哈顿等凭借在自动化仓库、物流供应链执行等方面强势进入市场，加之数不胜数的“散兵游勇”型软件公 司，物流信息化市场掠食者众多。

博科公司营销中心副总经理周龙说：“第三方物流企业的信息化被认为是拉动物流行业信息化的关键，但事实上，第三 方物流企业目前多数不赚钱，在信息化方面投入很小，而且这一块市场远远没有启动起来。”寄望已久的市场需求爆发点迟迟未到，但是参与竞争者却“人满为 患”，物流软件厂商打单难，赚钱更难也就不难理解。

其次是大系统和中小企业需求之间的错位。根据2005年中国物流信息中心对中国企业物流信息化现状和趋势的调查 情况看，未建立信息系统的企业绝大部分是小型企业，预计投资大于100万的比例只有1.8%，37.5%的企业投资低于10万元，这些数据可以看出，小型 企业的信息化需求潜力巨大。

但是正如中国物流与采购联合会副会长戴定一所指出，由于多数开发商认为，“物流信息化市场在低端不具备开发价 值”，多数厂商只是把眼光盯着几个有限的行业和著名企业，对小企业、小项目并不上心。比如海运、船运和集装箱运输这些高端物流项目确实利润丰厚，项目动辄 就是几百万，甚至10个亿投入，但是这一块市场基本上都被IBM、HP、SAP等等厂商所把持。

国内很多专业的物流软件厂商宁愿为极少的“高端客户”和大项目打得头破血流，也不愿意针对中小企业客户开发“适销对路”的产品。因此大家都做得很辛苦。

第三是高成本与低回报之间的错位。软件开发成本高昂，但是物流企业出得起的钱却很少，软件厂商基本上处于“做一个 亏一个”的恶性循环中。赵杨对记者说:“物流行业的需求千差万别，比如快速消费品和医药、烟草行业就是完全不同的流程，要把物流软件做成标准化产品基本上 是不可能的。目前市场上声称的所谓标准化的产品只不过是一种噱头而已。”由于绝大多数的物流项目都是定制化开发，不但项目实施的周期长，而且项目常常陷入 无休止的修改和二次开发的泥沼之中。

做“全”或者做“专”

“再辛苦，我们也要坚持到底。”一家专业物流软件厂商的总经理对记者说 :“不经历风雨怎么见彩虹。”这其实是多数物流软件厂商的心态，在投入了上千万元的资金、积累了一些客户基础以后，完全放弃物流信息化市场确实是很难。更何况，物流信息化可以说“前途是光明的”。

“但是物流软件厂商必须要改变，如果抱残守缺肯定只有死路一条。”采访中赵杨对物流软件厂商的未来并不十分看好。 “如果说要求解，物流软件厂商要么做全，要么做专。”赵杨认为，所谓做“全”就是不要局限于物流软件，而是由物流供应链切入到包括ERP、SCM、CRM 等业务系 ;而做“专”就是盯准一个行业做产品和客户。

物流信息化市场涉及的目标客户非常广泛，如储运公司、国际货代公司、船代公司、包裹快递公司、邮政部门、零售公司、大型工业企业中的物流部门等等。不同市场对信息化的需求既有一定的共性，又存在一定差异。物流软件厂商必须要立足自身实际情况，确定合适的目标市场。

也有分析人士认为，做专的另一种方式是提供细分化产品。物流管理是一个综合的系统工程，整个物流运作是运输、储 存、装卸、搬运、包装、流通加工、配送等基本功能的有机结合。如果厂商能围绕部门级信息系统如仓储管理系统、运输管理系统、配送管理系统、报关管理系统、 货代管理系统、快递管理系统等开发出一些精深且有特色的产品，将能够更大程度地增强自身的市场竞争力。

事实上，诸如上海博科这样的选择坚守的物流软件厂商也开始进行业务的调整。记者在采访中了解到，针对大型企业物 流的需求，博科将改变以前的单个物流项目的做法。周龙说：“我们的物流系统将和博科集团财务、ERP、供应链等产品组合成为一个整体，做成一个整体解决方 案提供给客户。”而对于中小型的物流公司，则通过平台化产品，通过渠道销售的方式满足客户需求。而记者在采访中得知，另一家知名的物流软件厂商招商迪辰也 “正在业务调整中”。

“物流软件厂商无论做专还是做全，都必须要做精”，赵杨强调说:“厂商的产品和品牌形象至关重要。”根据中国物 流信息中心最新的调查报告，物流客户对开发商最看重的几项条件分别是:成功案例(85%)、咨询与服务经验（73.3%）、品牌46.7%、价格因素 45%。对未建系统的企业调查显示，对有成功案例最看重(40%)，其次是品牌（26%）。由此可见，在未来的竞争中，物流软件厂商必须得拿“牌子”见 客，拿产品说话。

（计算机世界报 2005年12月05日 第47期 E5）

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() {...}
}

对spring 了解的不够精通，这两天在解决jms异常的过程中发现，spring中提供了jmsTrasactionManager，同样实现了事务管理接口。这样用 自动的拦截器，就可以象数据库一样自动控制事务。在同时配置了JMS和数据库事务的时候，两者同时有效。这样系统的消息和数据库事务就轻量级的一致了！

数据库的spring配置参见：http://steeven.cnblogs.com/archive/2005/06/14/174410.html
jms部分如下：

    <bean id="remoteJmsConnectionFactory"
        class="org.activemq.ActiveMQConnectionFactory">
        <property name="useEmbeddedBroker">
            <value>true</value>
        </property>
        <property name="brokerURL">
            <value>tcp://localhost:61616</value>
        </property>
    </bean>

    <bean id="jmsTM"
        class="org.springframework.jms.connection.JmsTransactionManager">
        <property name="connectionFactory">
            <ref bean="remoteJmsConnectionFactory" />
        </property>
    </bean>

    <bean id="jmsTransactionInterceptor"
        class="org.springframework.transaction.interceptor.TransactionInterceptor">
        <property name="transactionManager">
            <ref bean="jmsTM" />
        </property>
        <property name="transactionAttributeSource">
            <bean
                class="org.springframework.transaction.annotation.AnnotationTransactionAttributeSource" />
        </property>
    </bean>

    <bean
        class="org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor">
        <property name="transactionInterceptor">
            <ref bean="jmsTransactionInterceptor" />
        </property>
    </bean>

    <bean id="destResolver"
        class="test.message.EnumDestinationResolver" />

    <!-- for send jms to remote server -->
    <bean id="remoteJmsTemplate"
        class="org.springframework.jms.core.JmsTemplate">
        <property name="connectionFactory">
            <ref bean="remoteJmsConnectionFactory" />
        </property>
        <property name="destinationResolver">
            <ref local="destResolver" />
        </property>
    </bean>

@Transactional

{
    public void someMethod() {
        getJmsTemplate().send(someMessage);
    }
}

    /**
     * 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);
        }
}

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);
}

}
.....

package pub.capart;

import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class GrindServlet extends HttpServlet {
   protected void doGet(HttpServletRequest req, HttpServletResponse res)
         throws ServletException, IOException {
      Grinderv1 grinder = Grinderv1.getGrinder();
      long t1 = System.currentTimeMillis();
      grinder.grindCPU(13);
      long t2 = System.currentTimeMillis();

      PrintWriter pw = res.getWriter();
      pw.print("<html>\n< body> \n");
      pw.print("Grind Time = "+(t2-t1));
      pw.print("< body> \n< /html> \n");
   }
}

package pub.capart;

/**
* This is a simple class designed to simulate an application consuming
* CPU, memory, and contending for a synchronization lock.
*/
public class Grinderv1 {
   private static Grinderv1 singleton = new Grinderv1();
   private static final String randstr =
      "this is just a random string that I'm going to add up many many times";

   public static Grinderv1 getGrinder() {
      return singleton;
   }
   public synchronized void grindCPU(int level) {
      StringBuffer sb = new StringBuffer();
      String s = randstr;
      for (int i=0;i<level;++i) {
         sb.append(s);
         s = getReverse(sb.toString());
      }
   }
   public String getReverse(String s) {
      StringBuffer sb = new StringBuffer(s);
      sb = sb.reverse();
      return sb.toString();
   }
}