1．Duplicated Code
代码重复几乎是最常见的异味了。他也是Refactoring 的主要目标之一。代码重复往
往来自于copy-and-paste 的编程风格。与他相对应OAOO 是一个好系统的重要标志
（请参见我的duplicated code 一文：http://www.erptao.org/download.php?op=viewsdownload&sid=6）。

2．Long method
它是传统结构化的“遗毒“。一个方法应当具有自我独立的意图，不要把几个意图
放在一起，我的《大类和长方法》一文中有详细描述。

3．Large Class
大类就是你把太多的责任交给了一个类。这里的规则是One Class One Responsibility。

4．Divergent Change
一个类里面的内容变化率不同。某些状态一个小时变一次，某些则几个月一年才变
一次；某些状态因为这方面的原因发生变化，而另一些则因为其他方面的原因变一次。
面向对象的抽象就是把相对不变的和相对变化相隔离。把问题变化的一方面和另一
方面相隔离。这使得这些相对不变的可以重用。问题变化的每个方面都可以单独重用。
这种相异变化的共存使得重用非常困难。

5．Shotgun Surgery
这正好和上面相反。对系统一个地方的改变涉及到其他许多地方的相关改变。这些
变化率和变化内容相似的状态和行为通常应当放在同一个类中。

6．Feature Envy
对象的目的就是封装状态以及与这些状态紧密相关的行为。如果一个类的方法频繁
用get 方法存取其他类的状态进行计算，那么你要考虑把行为移到涉及状态数目最多的
那个类。

7．Data Clumps
某些数据通常像孩子一样成群玩耍：一起出现在很多类的成员变量中，一起出现在
许多方法的参数中…..，这些数据或许应该自己独立形成对象。

8．Primitive Obsession
面向对象的新手通常习惯使用几个原始类型的数据来表示一个概念。譬如对于范围，
他们会使用两个数字。对于Money，他们会用一个浮点数来表示。因为你没有使用对象
来表达问题中存在的概念，这使得代码变的难以理解，解决问题的难度大大增加。
好的习惯是扩充语言所能提供原始类型，用小对象来表示范围、金额、转化率、邮
政编码等等。

9．Switch Statement
基于常量的开关语句是OO 的大敌，你应当把他变为子类、state 或strategy。

10． Parallel Inheritance Hierarchies
并行的继承层次是shotgun surgery 的特殊情况。因为当你改变一个层次中的某一个
类时，你必须同时改变另外一个层次的并行子类。

11． Lazy Class
一个干活不多的类。类的维护需要额外的开销，如果一个类承担了太少的责任，应
当消除它。

12． Speculative Generality
一个类实现了从未用到的功能和通用性。通常这样的类或方法唯一的用户是test
case。不要犹豫，删除它。

13． Temporary Field
一个对象的属性可能只在某些情况下才有意义。这样的代码将难以理解。专门建立
一个对象来持有这样的孤儿属性，把只和他相关的行为移到该类。最常见的是一个特定
的算法需要某些只有该算法才有用的变量。

14． Message Chain
消息链发生于当一个客户向一个对象要求另一个对象，然后客户又向这另一对象要
求另一个对象，再向这另一个对象要求另一个对象，如此如此。这时，你需要隐藏分派。

15． Middle Man
对象的基本特性之一就是封装，而你经常会通过分派去实现封装。但是这一步不能走得太远，如果你发现一个类接口的一大半方法都在做分派，你可能需要移去这个中间
人。

16． Inappropriate Intimacy
某些类相互之间太亲密，它们花费了太多的时间去砖研别人的私有部分。对人类而
言，我们也许不应该太假正经，但我们应当让自己的类严格遵守禁欲主义。

17． Alternative Classes with Different Interfaces
做相同事情的方法有不同的函数signature，一致把它们往类层次上移，直至协议一
致。

18． Incomplete Library Class
要建立一个好的类库非常困难。我们大量的程序工作都基于类库实现。然而，如此
广泛而又相异的目标对库构建者提出了苛刻的要求。库构建者也不是万能的。有时候我
们会发现库类无法实现我们需要的功能。而直接对库类的修改有非常困难。这时候就需
要用各种手段进行Refactoring。

19． Data Class
对象包括状态和行为。如果一个类只有状态没有行为，那么肯定有什么地方出问题
了。

20． Refused Bequest
超类传下来很多行为和状态，而子类只是用了其中的很小一部分。这通常意味着你
的类层次有问题。

21． Comments
经常觉得要写很多注释表示你的代码难以理解。如果这种感觉太多，表示你需要
Refactoring。

public class MyThread_1 extends Thread
{
public void run()
{
//some code 
}
}

eg.实现Runnable接口

public class MyThread_2 implements Runnable
{
public void run()
{
//some code 
}
}

当使用继承创建线程，这样启动线程：

new MyThread_1().start()

当使用实现接口创建线程，这样启动线程：

new Thread(new MyThread_2()).start()

注意，其实是创建一个线程实例，并以实现了Runnable接口的类为参数传入这个实例，当执行这个线程的时候，MyThread_2中run里面的代码将被执行。
下面是完成的例子：

public class MyThread implements Runnable
{ 

public void run()
{ 
System.out.println("My Name is "+Thread.currentThread().getName()); 
} 
public static void main(String[] args)
{
new Thread(new MyThread()).start(); 
}
} 

执行后将打印出：
My Name is Thread-0

你也可以创建多个线程，像下面这样

new Thread(new MyThread()).start();
new Thread(new MyThread()).start();
new Thread(new MyThread()).start();

那么会打印出：
My Name is Thread-0
My Name is Thread-1
My Name is Thread-2

看了上面的结果，你可能会认为线程的执行顺序是依次执行的，但是那只是一般情况，千万不要用以为是线程的执行机制；影响线程执行顺序的因素有几点：首先看看前面提到的优先级别

public class MyThread implements Runnable
{ 

public void run()
{ 
System.out.println("My Name is "+Thread.currentThread().getName()); 
} 
public static void main(String[] args)
{
Thread t1=new Thread(new MyThread());
Thread t2=new Thread(new MyThread());
Thread t3=new Thread(new MyThread());
t2.setPriority(Thread.MAX_PRIORITY);//赋予最高优先级
t1.start();
t2.start();
t3.start();
}
} 

再看看结果：
My Name is Thread-1
My Name is Thread-0
My Name is Thread-2


线程的优先级分为10级，分别用1到10的整数代表，默认情况是5。上面的t2.setPriority(Thread.MAX_PRIORITY)等价与t2.setPriority(10）
然后是线程程序本身的设计，比如使用sleep,yield,join，wait等方法（详情请看JDKDocument)

public class MyThread implements Runnable
{ 
public void run()
{ 
try
{
int sleepTime=(int)(Math.random()*100);//产生随机数字，
Thread.currentThread().sleep(sleepTime);//让其休眠一定时间，时间又上面sleepTime决定
//public static void sleep(long millis)throw InterruptedException （API）
System.out.println(Thread.currentThread().getName()+" 睡了 "+sleepTime);
}catch(InterruptedException ie)//由于线程在休眠可能被中断，所以调用sleep方法的时候需要捕捉异常
{
ie.printStackTrace();
} 
} 
public static void main(String[] args)
{
Thread t1=new Thread(new MyThread());
Thread t2=new Thread(new MyThread());
Thread t3=new Thread(new MyThread());
t1.start();
t2.start();
t3.start();
}
}

执行后观察其输出：

Thread-0 睡了 11
Thread-2 睡了 48
Thread-1 睡了 69



上面的执行结果是随机的，再执行很可能出现不同的结果。由于上面我在run中添加了休眠语句，当线程休眠的时候就会让出cpu，cpu将会选择执行处于runnable状态中的其他线程，当然也可能出现这种情况，休眠的Thread立即进入了runnable状态，cpu再次执行它。
[线程组概念]
线程是可以被组织的，java中存在线程组的概念，每个线程都是一个线程组的成员,线程组把多个线程集成为一个对象,通过线程组可以同时对其中的多个线程进行操作,如启动一个线程组的所有线程等.Java的线程组由java.lang包中的Thread——Group类实现.
ThreadGroup类用来管理一组线程,包括:线程的数目,线程间的关系,线程正在执行的操作,以及线程将要启动或终止时间等.线程组还可以包含线程组.在Java的应用程序中,最高层的线程组是名位main的线程组,在main中还可以加入线程或线程组,在mian的子线程组中也可以加入线程和线程组,形成线程组和线程之间的树状继承关系。像上面创建的线程都是属于main这个线程组的。
借用上面的例子，main里面可以这样写：

public static void main(String[] args)
{
/***************************************
ThreadGroup(String name) 
ThreadGroup(ThreadGroup parent, String name) 
***********************************/
ThreadGroup group1=new ThreadGroup("group1");
ThreadGroup group2=new ThreadGroup(group1,"group2");
Thread t1=new Thread(group2,new MyThread());
Thread t2=new Thread(group2,new MyThread());
Thread t3=new Thread(group2,new MyThread());
t1.start();
t2.start();
t3.start();
}

线程组的嵌套，t1,t2,t3被加入group2,group2加入group1。
另外一个比较多就是关于线程同步方面的，试想这样一种情况，你有一笔存款在银行，你在一家银行为你的账户存款，而你的妻子在另一家银行从这个账户提款，现在你有1000块在你的账户里面。你存入了1000，但是由于另一方也在对这笔存款进行操作，人家开始执行的时候只看到账户里面原来的1000元，当你的妻子提款1000元后，你妻子所在的银行就认为你的账户里面没有钱了，而你所在的银行却认为你还有2000元。
看看下面的例子：

class BlankSaving //储蓄账户
{
private static int money=10000;
public void add(int i)
{
money=money+i;
System.out.println("Husband 向银行存入了 [￥"+i+"]");
}
public void get(int i)
{
money=money-i;
System.out.println("Wife 向银行取走了 [￥"+i+"]");
if(money<0)
System.out.println("余额不足！"); 
}
public int showMoney()
{
return money;
}
} 


class Operater implements Runnable
{
String name;
BlankSaving bs;
public Operater(BlankSaving b,String s)
{
name=s;
bs=b;



}
public static void oper(String name,BlankSaving bs)
{



if(name.equals("husband"))
{
try
{
for(int i=0;i<10;i++)
{
Thread.currentThread().sleep((int)(Math.random()*300));
bs.add(1000);
}
}catch(InterruptedException e){}
}else
{
try
{



for(int i=0;i<10;i++)
{
Thread.currentThread().sleep((int)(Math.random()*300));
bs.get(1000);
}
}catch(InterruptedException e){}
}
}
public void run()
{
oper(name,bs);
} 
}
public class BankTest 
{
public static void main(String[] args)throws InterruptedException
{
BlankSaving bs=new BlankSaving();
Operater o1=new Operater(bs,"husband");
Operater o2=new Operater(bs,"wife");
Thread t1=new Thread(o1);
Thread t2=new Thread(o2);
t1.start();
t2.start();
Thread.currentThread().sleep(500);
}



}

下面是其中一次的执行结果：



---------first--------------
Husband 向银行存入了 [￥1000]
Wife 向银行取走了 [￥1000]
Wife 向银行取走了 [￥1000]
Husband 向银行存入了 [￥1000]
Wife 向银行取走了 [￥1000]
Husband 向银行存入了 [￥1000]
Wife 向银行取走了 [￥1000]
Husband 向银行存入了 [￥1000]
Wife 向银行取走了 [￥1000]
Husband 向银行存入了 [￥1000]
Husband 向银行存入了 [￥1000]
Wife 向银行取走了 [￥1000]
Husband 向银行存入了 [￥1000]
Husband 向银行存入了 [￥1000]
Wife 向银行取走了 [￥1000]
Wife 向银行取走了 [￥1000]
Husband 向银行存入了 [￥1000]
Wife 向银行取走了 [￥1000]
Wife 向银行取走了 [￥1000]
Husband 向银行存入了 [￥1000]

看到了吗，这可不是正确的需求，在husband还没有结束操作的时候，wife就插了进来，这样很可能导致意外的结果。解决办法很简单，就是将对数据进行操作方法声明为synchronized,当方法被该关键字声明后，也就意味着，如果这个数据被加锁，只有一个对象得到这个数据的锁的时候该对象才能对这个数据进行操作。也就是当你存款的时候，这笔账户在其他地方是不能进行操作的，只有你存款完毕，银行管理人员将账户解锁，其他人才能对这个账户进行操作。
修改public static void oper(String name,BlankSaving bs)为public static void oper(String name,BlankSaving bs)，再看看结果:

Husband 向银行存入了 [￥1000]
Husband 向银行存入了 [￥1000]
Husband 向银行存入了 [￥1000]
Husband 向银行存入了 [￥1000]
Husband 向银行存入了 [￥1000]
Husband 向银行存入了 [￥1000]
Husband 向银行存入了 [￥1000]
Husband 向银行存入了 [￥1000]
Husband 向银行存入了 [￥1000]
Husband 向银行存入了 [￥1000]
Wife 向银行取走了 [￥1000]
Wife 向银行取走了 [￥1000]
Wife 向银行取走了 [￥1000]
Wife 向银行取走了 [￥1000]
Wife 向银行取走了 [￥1000]
Wife 向银行取走了 [￥1000]
Wife 向银行取走了 [￥1000]
Wife 向银行取走了 [￥1000]
Wife 向银行取走了 [￥1000]
Wife 向银行取走了 [￥1000]



当丈夫完成操作后，妻子才开始执行操作，这样的话，对共享对象的操作就不会有问题了。
[wait and notify]
你可以利用这两个方法很好的控制线程的执行流程，当线程调用wait方法后，线程将被挂起，直到被另一线程唤醒（notify）或则是如果wait方法指定有时间得话，在没有被唤醒的情况下，指定时间时间过后也将自动被唤醒。但是要注意一定，被唤醒并不是指马上执行，而是从组塞状态变为可运行状态，其是否运行还要看cpu的调度。
事例代码：

class MyThread_1 extends Thread
{
Object lock;
public MyThread_1(Object o)
{
lock=o;
}
public void run()
{
try
{
synchronized(lock)
{
System.out.println("Enter Thread_1 and wait");
lock.wait();
System.out.println("be notified");
}
}catch(InterruptedException e){}
}
}
class MyThread_2 extends Thread
{
Object lock;
public MyThread_2(Object o)
{
lock=o;
}
public void run()
{
synchronized(lock)
{
System.out.println("Enter Thread_2 and notify");
lock.notify();
}
}
}
public class MyThread
{ 
public static void main(String[] args)
{
int[] in=new int[0];//notice
MyThread_1 t1=new MyThread_1(in);
MyThread_2 t2=new MyThread_2(in);
t1.start();
t2.start();
}
}

执行结果如下：
Enter Thread_1 and wait
Enter Thread_2 and notify
Thread_1 be notified

可能你注意到了在使用wait and notify方法得时候我使用了synchronized块来包装这两个方法，这是由于调用这两个方法的时候线程必须获得锁，也就是上面代码中的lock[]，如果你不用synchronized包装这两个方法的得话，又或则锁不一是同一把，比如在MyThread_2中synchronized(lock)改为synchronized(this),那么执行这个程序的时候将会抛出java.lang.IllegalMonitorStateException执行期异常。另外wait and notify方法是Object中的，并不在Thread这个类中。最后你可能注意到了这点：int[] in=new int[0];为什么不是创建new Object而是一个0长度的数组，那是因为在java中创建一个0长度的数组来充当锁更加高效。

Thread作为java中一重要组成部分，当然还有很多地方需要更深刻的认识，上面只是对Thread的一些常识和易错问题做了一个简要的总结，若要真正的掌握java的线程，还需要自己多做总结

Java是目前最流行的面向对象的编程语言之一，Java支持UTF-8、ISO-8

影响Java中字体编码正确显示的有几个因素: 1)数据库的连接方式; 2)网页中使用的字体编码; 3)数据库里存放数据的字体编码; 4)Java的缺省字体编码。如果在编程中遇到不能正确显示中文时，要先弄清楚以上几项所使用的字体编码，再分析找出原因，即可解决问题。

众所周知，JSP是Java的一种，和网页有关，而网页也有自己的中文编码系统，所以JSP处理中文要比纯Java的类文件更为麻烦。本文的测试数据库是MySQL3.2，数据库连接驱动是用org.gjt.mm.mysql.Driver，这里主要讨论UTF-8和GBK的显示( GB2312是GBK的一个子集，Java中可以使用GBK来代替GB系列)。我们先来研究JSP中字体编码问题， 下面第一到第六点是针对JSP的(因为从数据库里读出中文数据与写入中文数据有所区别，咱们分别说明，前三点是从读取数据库到显示在网页，后三点是从网页输入数据到存入数据库)，第七到第九点针对纯Java的类文件。 以下rs表示ResultSet的一个实例，是执行Select语句之后产生的数据集。

一、数据库连接方式使用UTF-8

在连接数据库的驱动后面加上这句参数useUnicode=true&characterEncoding=

UTF-8，例如jdbc:mysql://localhost/DBVF?autoReconnect=true&useUnicode=

true&characterEncoding=UTF-8，从数据库里读出中文显示在使用GBK的JSP的网页里，如果数据库里存放的字体编码是UTF-8，在JSP中使用 str=new String(rs.getBytes(1),"UTF-8")或者str=rs.getString(1)，可以正确显示中文。如果数据库里存放的是GBK数据，那么JSP中也要使用str=new String(rs.getBytes(1),"GBK")来显示正确的中文。值得注意的是如果页面使用UTF-8，数据库里存放的是UTF-8，也可以用str=new String(rs.getBytes(1),"GBK")正确显示中文。如果网页是UTF-8，而数据库里存放的是GBK，无法直接显示中文，需要2步转换, str=new String(rs.getBytes(1),"GBK"); 再str=new String(str.getBytes("UTF-8"),"GBK")，才可以正确显示中文。

二、数据库连接方式使用GBK

在连接数据库的驱动后面加上这句参数useUnicode=true&characterEncoding=

GBK,例如jdbc:mysql://localhost/DBVF?autoReconnect=true&UseUnicode=true&

characterEncoding=GBK，从数据库里读出中文，显示在使用GBK的JSP的网页里，如果数据库里存放的字体编码是UTF-8，在JSP中一定要使用 str=new String(rs.getBytes(1),"UTF-8")，才正确显示中文。如果数据库里存放的是GBK数据，那么JSP中也要使用str=new String(rs.getBytes(1),"GBK") 或者直接使用str=rs.getString(1)，即可显示正确的中文。 如果网页是UTF-8，而数据库里存放的是GBK，只能用str=new String(rs.getString(1).getBytes("UTF-8"),"GBK")的方法来显示中文; 如果网页是UTF-8，而数据库里存放的是UTF-8，可用str=new String(rs.getBytes(1),"GBK") 或者rs.getString(1)方法来显示中文。

三、使用缺省数据库连接方式

连接数据库的驱动后面没有这句参数useUnicode=&characterEncoding=，例如jdbc:mysql://localhost/DBVF?autoReconnect=true，没有参数useUnicode=true&characterEncoding，表示使用默认的ISO-8895-1编码。

1. 从数据库里读出中文，显示在GBK的网页里。如果数据库里存放的字体编码是UTF-8，在JSP网页中一定要使用语句 str=new String(rs.getBytes(1),"UTF-8") 或者str= new String(rs.getString(1).getBytes("ISO-8859-1"),"UTF-8")，才可正确显示中文。如果数据库里存放的是GBK数据，那么JSP中也要使用str=new String(rs.getBytes(1),"GBK")或str=new String(rs.getString(1).getBytes("ISO-8859-1"),"GBK") 显示正确的中文。

2. 如果网页是UTF-8,不能直接正确显示GBK，需要2步转换，str=new String(rs.getBytes(1),"GBK")，再str=new String(str.getBytes("UTF-8"),"GBK") 才可以正确显示中文。如果数据库里存的是UTF-8，直接用str=new String(rs.getBytes(1),"GBK")或者str=new String(rs.getString(1).getBytes("ISO-8859-1"),"GBK")就可以显示中文了。

以上是读取数据库里中文正确显示在网页上，下面三点是如何正确存入数据库。

四、数据库连接方式使用UTF-8编码

JSP中要把网页输入的中文存入数据库，通常有一个提交(Submit)的过程，是用str=request.getParameter("username")，然后执行update或者insert语句来存入数据库。如何赋值给str很重要，而且这里中文输入与网页所使用的字体编码有关。

1、 网页使用UTF-8，使用str= new String(request.getParameter("username").getBytes("ISO-8859-1"),"UTF-8")或者str= new String(request.getParameter("username").getBytes(),"UTF-8")，都可以使得存到数据库里的数据是UTF-8编码。

2. 网页使用GBK，使用str= new String(request.getParameter("username").getBytes(),"GBK")，那么存入数据库的是UTF-8编码。

3. 值得注意的是使用UTF-8的数据库连接方式不能存得GBK。

五、数据库连接方式使用GBK编码

1. 输入使用GBK网页，存到数据库里是GBK的方法: str= new String(request.getParameter("username").getBytes("ISO-8859-1"),"GBK") 或者str= new String(request.getParameter("username").getBytes(),"GBK")。

2. 网页使用GBK，想存入UTF-8到数据库里，要分2步: 先str=new String(request.getParameter("username").getBytes(),"GBK")，再str=new String(str.getBytes("UTF-8"),"GBK")即可。

3. 网页使用UTF-8，而且使用str= new String(request.getParameter("username").getBytes("ISO-8859-1"),"GBK") 或者str= new String(request.getParameter("username").getBytes(),"UTF-8")，那么存到数据库里的数据是UTF-8编码。

4. 网页使用UTF-8，而且使用str= new String(request.getParameter("username").getBytes("ISO-8859-1"),"UTF-8")，那么存到数据库里的数据是GBK编码。

六、数据库连接方式使用缺省，即不使用参数useUnicode和characterEncoding

1. 网页使用GBK，如果使用str= request.getParameter("username")或者str= new String(request.getParameter("username").getBytes())，那么在数据库里的数据是GBK码。网页使用UTF-8 和使用str= request.getParameter("username")，则存入数据库是UTF-8编码。

2. 如果使用str= new String(request.getParameter("username").getBytes("ISO-8859-1"))，那么根据网页提供的字体编码而存到数据库里，比如是UTF-8的网页，那么存到数据库中就是UTF-8编码，如果使用GBK网页，那么存到数据库里的字就是GBK编码。

3. 如果使用str= new String(request.getParameter("username").getBytes("UTF-8"),"UTF-8")这一种组合能存到正确的数据外，其他存到数据库里的数据则都是乱码或者错误码。在这个UTF-8组合的特例中，网页使用的是GBK，则存放到数据库里就是GBK，网页使用UTF-8，那么存到数据库里的就是UTF-8。

4. 网页是GBK的要存得UTF-8，一定需要2步: company=new String(request.getParameter("company").getBytes(),"GBK")和company=new String(company.getBytes("UTF-8"))。

5. 网页是UTF-8的，不能存得GBK在数据库里，一句话，改变数据库连接方式不能存得GBK码。

以上所有的都是基于JSP网页和数据库交换数据，下面讨论一下纯JAVA编程下的字体编码转换。

七、数据库连接方式使用UTF-8编码

1. 数据库里的中文是UTF-8，可以转换为GBK,但不能把GBK存入数据库。

2. 数据库是GBK，如果转换为UTF-8，使用content=new String(rs.getBytes(2),"GBK")直接将content存入数据库就可为UTF-8。

八、数据库连接方式使用GBK编码

1. 数据库里的中文是UTF-8，如果转换为GBK，使用content= new String(rs.getString(2).getBytes(),"UTF-8"),再直接使用update或者insert语句插入到数据库，即存得GBK。如果使用content= new String(rs.getString(2).getBytes(),"GBK")或者content= new String(rs.getString(2).getBytes())，再存入数据库即存得还是UTF-8编码。

2. 数据库里的中文是GBK，如果转换为UTF-8，使用content= new String(rs.getString(2).getBytes("UTF-8"))或者content= new String(rs.getString(2).getBytes("UTF-8"),"GBK")，再直接使用update或者insert语句插入到数据库,即存得UTF-8。

3. 如果某个String是GBK，要转换为UTF-8，也是使用content= new String(GBKstr.getBytes("UTF-8"))或者content= new String(GBKstr.getBytes("UTF-8"),"GBK"); 如果某个String是UTF-8，要转换为GBK，应该使用new String(UTFstr.getBytes("GBK"),"UTF-8")。

九、数据库连接方式使用缺省,即不跟参数

1. str2=new String(GBKstr.getBytes("UTF-8"),"ISO-8859-1")，可以将数据库里的GBK编码转换为UTF-8。

2. 读取UTF-8然后存入UTF-8，则用str1=new String(UTFstr.getBytes(),"ISO-8859-1")或者str1=new String(UTFstr.getBytes("GBK"),"ISO-8859-1")。

3. 不能实现数据库里的UTF-8转换为GBK。

如果采用UTF-8的数据库连接方式或者缺省数据连接方式，那么无法将UTF-8转为GBK；而GBK的数据库连接方式可以实现UTF-8和GBK的相互转换。建议大家采用GBK的数据连接方式。

Dale Green著

JSP WU 译

一个典型的企业应用程序在一个或多个数据库中访问和存储信息。因为这些信息对于商业操作非常重要，它必须精确、实时、可靠。如果允许多个程序同时更新相同的数据，就会破坏数据的完整性。如果在一个商业交易处理过程中，部分数据被更新后系统崩溃也将破坏数据完整性。事务通过预防以上情况的发生确保数据的完整性。事务控制多个应用程序对数据库的并发操作。如果发生系统崩溃，事务确保恢复的数据崩溃前将保持一致。

本章内容：

什么是事务

容器管理事务

事务的属性

回滚容器管理事务

同步会话bean实例变量

容器管理事务中不允许使用的方法

Bean 管理事务

JDBC事务

JTA  事务

非提交返回事务

在Bean管理事务中不允许使用的方法

企业Bean事务摘要

事务超时

隔离级别

更新多个数据库

Web 组件事务

一．什么是事务

模拟一个商业交易，应用程序需要完成几个步骤。例如，一个财物应用程序，可能会将资金从经常性帐户（checking account）转到储蓄性账户（saving account），该交易的伪码表示如下：

begin transaction

debit checking account

credit savings account

update history log

commit transaction

三个步骤要么全部完成，要么一个都不做。否则数据完整性将被破坏。因为事务中的所有步骤被看作一个统一的整体，所以事务一般被定义为一个不可分割的工作单元。

结束事务有两种方法：提交或者回滚。当一个事务提交，数据修改被保存。如果事务中有一个步骤失败，事务就回滚，这个事务中的已经执行的动作被撤销。例如在上面的伪码中，如果在处理第二步的时候硬盘驱动器崩溃，事务的第一步将被撤销。尽管事务失败，数据的完整性不会被破坏，因为帐目仍然保持平衡。

前面伪码中，begin和commit标明了事务的界限。当设计一个企业Bean的时候，你要决定怎样通过容器管理或bean管理事务来指定事务界限。

二．容器管理事务

在容器管理事务的企业Bean中，EJB容器来设定事务界线。你能够在任何企业Bean中使用容器管理事务：会话Bean、实体Bean或者 Message-driven Bean。容器管理事务简化了开发，因为企业Bean不用编码来显式制定事务界限。代码不包括开始结束事务的语句。典型的，容器会在一个企业Bean的方法被调用前立即开始一个事务，在这个方法退出以前提交这个事务。每个方法都关联一个事务。在一个方法中不允许嵌套或多个的事务存在。容器管理事务不需要所有的方法都关联事务。当部署一个Bean时，通过设定部署描述符中的事务属性来决定方法是否关联事务和如何关联事务。

事务的属性

一个事务的属性控制了事务的使用范围。图 14-1说明了为什么控制事务的范围很重要。图中，method-A开始一个事务然后调用Bean-2中的method-B.它运行在method-A开始的事务中还是重新执行一个新的事务？结果要看method-B中的事务属性。

图 14-1 Transaction Scope

一个事务属性可能有下面的属性之一：

☆ Required

☆ RequiresNew

☆ Mandatory

☆ NotSupported

☆ Supports

☆ Never

Required

如果客户端正在一个运行的事务中调用一个企业Bean的方法，这个方法就在这个客户端的事务中执行。如果客户端不关联一个事务，这个容器在运行该方法前开始一个新的事务。

Required属性在许多事务环境中可以很好的工作，因此你可以把它作为一个默认值，至少可以在早期开发中使用。因为事务的属性是在部署描述符中声明的，在以后的任何时候修改它们都很容易。

RequiresNew

如果客户端在一个运行的事务中调用企业Bean的方法，容器的步骤是：

1．挂起客户端的事务

2．开始一个新的事务

3．代理方法的调用

4．方法完成后重新开始客户端的事务

如果客户端不关联一个事务，容器运行这个方法以前同样开始一个新的事务。如果你想保证该方法在任何时候都在一个新事物中运行，使用RequiresNew属性。

Mandatory

如果客户端在一个运行的事务中调用企业Bean的方法，这个方法就在客户端的事务中执行。如果客户端不关联事务，容器就抛出TransactionRequiredException 异常。

如果企业Bean的方法必须使用客户端的事务，那么就使用Mandatory属性。

NotSupported

如果客户端在一个运行的事务中调用企业Bean的方法，这个容器在调用该方法以前挂起客户端事务。方法执行完后，容器重新开始客户端的事务。

如果客户端不关联事务，容器在方法运行以前不会开始一个新的事务。为不需要事务的方法使用NotSupported属性。因为事务包括整个过程，这个属性可以提高性能。

Supports

如果客户端在一个运行的事务中调用企业Bean的方法，这个方法在客户端的事务中执行，如果这个客户端不关联一个事务，容器运行该方法前也不会开始一个新的事务。因为该属性使方法的事务行为不确定，你应该谨慎使用Supports属性。

Never

如果客户端在一个运行的事务中调用企业Bean的方法，容器将抛出RemoteException异常。如果这个客户端不关联一个事务，容器运行该方法以前不会开始一个新的事务。

Summary of Transaction Attributes（事务属性概要）

表 14-1 列出了事务属性的影响。事务T1和T2都被容器控制。T1是调用企业Bean方法的客户端的事务环境。在大多数情况下，客户端是其它的企业Bean。T2是在方法执行以前容器启动的事务。在表 14-1中，“None”的意思是这个商业方法不在容器控制事务中执行。然而，该商业方法中的数据库操作可能在DBMS管理控制的事务中执行。

Setting Transaction Attributes （设定事务属性）

因为事务属性被保存在配置描述符中，他们会在J2EE应用程序开发的几个阶段被改变：创建企业Bean，应用程序装配和部署。然而， 当创建这个Bean的时候指定它的属性是企业Bean开发者的责任。只有将该组件装配到一个更大的应用程序时可以由开发者修改该属性，而不要期待J2EE应用程序部署者来指定该事务属性。

你可以为整个企业Bean或者单个方法指定事务属性。如果你为整个企业Bean和它某个方法各指定一个事务属性，为该方法指定的事务属性优先。当为单个方法指定事务属性时，不同类型企业Bean的要求也不同。会话Bean需要为商业方法定义属性属性，但create方法不需要定义事务属性。实体Bean需要为商业方法、create方法、remove方法和查找（finder）方法定义事务属性。Message-driven Bean需要为onMessage方法指定属性事务，而且只能是Required和NotSupported其中之一。

容器管理事务的回滚

　　在以下两中情况下，事务将回滚。第一，如果产生一个系统异常，容器将自动回滚该事务。第二，通过调用EJBContext接口SetRollbackOnly方法，Bean方法通知容器回滚该事务。如果Bean抛出一个应用异常，事务将不会自动回滚，但可以调用SetRollbackOnly回滚。对于一个系统和应用的异常，参考第5章的处理异常一节。

下面这个例子的代码在j2eetorial/examples/src/bank目录下。在命令行窗口下进入j2eetutorial/examples目录执行ant bank命令编译这些代码，执行 ant create-bank-table命令创建要用到的表。一个BankApp.ear样本文件在j2eetutorial/examples/ears目录下。通过BnankEJB 实例的transferToSaving方法来说明setRollbackOnly方法的用法。如果余额检查出现负数，那么transferToSaving调用setRollBackOnly回滚事务并抛出一个应用程序异常（InsufficientBalanceException）。updateChecking和updateSaving 方法更新数据表。如果更新失败，这两个方法抛出SQLException异常而transgerToSaving方法抛出EJBException异常。因为EJBException是一个系统异常，它使容器事务自动回滚事务。TransferTuSaving 方法的代码如下：

public void transferToSaving(double amount) throws

   InsufficientBalanceException  {

  checkingBalance -= amount;

   savingBalance += amount;

  try {

      updateChecking(checkingBalance);

      if (checkingBalance < 0.00) {

         context.setRollbackOnly();

         throw new InsufficientBalanceException();

      }

      updateSaving(savingBalance);

   } catch (SQLException ex) {

       throw new EJBException

          ("Transaction failed due to SQLException: "

          + ex.getMessage());

   }

}

当一个容器回滚一个事务，它总是会撤消事务中已执行的SQL语句造成的数据改动。然而，仅仅在实体Bean中容器回滚才会改变Bean的实例变量（与数据库状态有关的字段）。（这是因为容器会自动调用实体Bean的ejbLoad方法，该方法从数据库中读入实例变量的值。）当发生回滚，会话Bean必须显式重新设置所有被事务改动过的实例变量。重设会话Bean的实例变量最简单的方法是实现SessionSynchronization接口。

同步会话Bean的实例变量

SessionSynchronization接口是可选的，它允许你在Bean的实例变量和它们在数据库中的相应值之间保持同步。容器会在事务的几个主要阶段调用SessionSynchronization接口的对应方法—afterBegin、beforeCompletion和afterCompletion。

AfterBegin方法通知Bean实例一个新的事务已经开始。容器在调用商业方法以前立即调用afterBegin方法。afterBegin方法是从数据库中读入实例变量值的最佳位置。例如，在BanBean类中，在afterBegin方法中从读入了CheckingBalance和savingBalance变量的值：

  public void afterBegin() {

  System.out.println("afterBegin()");

   try {

      checkingBalance = selectChecking();

      savingBalance = selectSaving();

   } catch (SQLException ex) {

       throw new EJBException("afterBegin Exception: " +

           ex.getMessage());

   }

}

商业方法方法完成以后，容器调用beforeCompletion方法，不过仅仅是在事务提交以前。BeforeCompletion方法是会话Bean回滚事务的最后时机（通过调用setRollbackOnly方法）.如果会话Bean还没有实例变量的值更新数据库，就在beforCompletion方法里实现。

afterCompletion方法指出事务已经完成。它只有一个布尔型的参数，true表示事务被正确提交false表示事务回滚。如果事务回滚，会话Bean可以在该方法中从数据库中重新读取它的实例变量值：

public void afterCompletion(boolean committed) {

  System.out.println("afterCompletion: " + committed);

   if (committed == false) {

      try {

         checkingBalance = selectChecking();

         savingBalance = selectSaving();

      } catch (SQLException ex) {

          throw new EJBException("afterCompletion SQLException:

         " + ex.getMessage());

      }

   }

}

容器管理事务中不允许使用的方法

你不应该调用可能干扰容器设置的事务界线的方法，下面列出了所有禁止的方法：

☆ java.sql.Connection接口的commit、setAutoCommit和rollback方法

☆ javax.ejb.EJBContext 接口的getUserTransaction方法

☆ javax.transaction.UserTransaction接口的所有方法

然而你可以在Bean管理事务中使用这些方法设置事务界限。

三．Bean管理事务

在一个Bean管理事务中，会话Bean或者Message-driven Bean是用代码显式设置事务界线的。实体Bean不能使用Bean管理事务，只能使用容器管理的事务。虽然容器管理事务Bean需要较少的代码，但它也有一个局限：方法执行时，它只能关联一个事务或不关联任何事务。如果这个局限使你Bean编码困难，你应该考虑使用Bean管理事务。（译者：实际上J2EE服务器不支持嵌套事物，那么Bean管理事务唯一的优点就是可以在一个方法中一次启动多个事务）

下面的伪码很好说明了Bean管理事对商业逻辑的紧密控制。通过检查各种条件，伪码决定是否在商业方法中启动或停止不同的事务。

begin transaction

...

update table-a

...

if (condition-x)

   commit transaction

else if (condition-y)

   update table-b

   commit transaction

else

   rollback transaction

   begin transaction

   update table-c

   commit transaction

当为会话Bean或Message-driver Bean的Bean管理事务编码时，你必须决定是使用jdbc或者JTA事务。下面的内容论述了两种事务类型。

JDBC 事务

JDBC事务通过DBMS事务管理器来控制。你可能会为了使用会话Bean中的原有代码而采用JDBC事务将这些代码封装到一个事务中。使用JDBC事务，要调用java.sql.Connection接口的commit和rollback方法。事务启动是隐式的。一个事务的从最近的提交、回滚或连接操作后的第一个SQL的语句开始。（这个规则通常是正确的，但可能DBMS厂商的不同而不同）

代码资源

下面的例子在j2eetutorial/examples/src/ejb/warehouse目录下。在命令行窗口中进入j2eetutorial/examples目录执行ant bank命令编译这些源文件，执行ant create-warehouse-table命令创建要用到的表，一个样本WarehouseApp.ear文件在j2eetutorial/example/ears 目录下。

下面的代码来自WarehouseEJB例子，一个会话Bean通过使用Connection接口的方法来划定Bean管理事务界限。ship方法以调用名为con的连接对象的setAutoCommit方法开始，该方法通知DBMS不要自动提交每个SQL语句。接下来ship 方法更新order_item和inventory数据表。如果更新成功，这个事务就会被提交。如果出现异常，事务就回滚。

public void ship (String productId, String orderId, int

quantity) {

  try {

      con.setAutoCommit(false);

      updateOrderItem(productId, orderId);

      updateInventory(productId, quantity);

      con.commit();

   } catch (Exception ex) {

       try {

          con.rollback();

          throw new EJBException("Transaction failed: " +

             ex.getMessage());

       } catch (SQLException sqx) {

           throw new EJBException("Rollback failed: " +

              sqx.getMessage());

       }

   }

}

JTA 事务

JTA是Java Transaction API 的缩写。这些API 允许你用独立于具体的事务管理器实现的方法确定事务界限。J2EE SDK 事务管理器通过Java事务服务（Java Transaction Service, JTS）实现。但是你的代码并不直接调用JTS中的方法，而是调用JTA方法来替代，JTA方法会调用底层的JTS实现。

JTA事务被J2EE 事务管理器管理。你可能需要使用一个JTA事务，因为它能够统一操作不同厂商的数据库。一个特定DBMS的事务管理器不能工作在不同种类的数据库上。然而J2EE事务管理器仍然有一个限制——它不支持嵌套事务。就是说，它不能在前一个事务结束前启动另一个事务。

下面例子的源代码在j2eetutorial/examples/src/ejb/teller目录下，在命令行窗口进入j2eetutorial/examples目录，执行ant teller命令编译这些源文件，执行ant create-bank-teller命令创建要用到的表。一个样本TellerApp.ear文件在j2eetutorial/examples/ears目录下。

要自己确定事务界限，可以调用javax.transaction.UserTransaction接口的begin、commit和rollback方法来确定事务界限（该接口只能在SessionBean中使用，实体Bean不允许使用用户自定义的）。下面选自TellerBean类的代码示范了UserTransaction的用法。begin和commit方法确定了数据库操作的事务界限，如果操作失败则调用rollback回滚事务并抛出EJBException异常。

public void withdrawCash(double amount) {

  UserTransaction ut = context.getUserTransaction();

  try {

      ut.begin();

      updateChecking(amount);

      machineBalance -= amount;

      insertMachine(machineBalance);

      ut.commit();

   } catch (Exception ex) {

       try {

          ut.rollback();

       } catch (SystemException syex) {

           throw new EJBException

              ("Rollback failed: " + syex.getMessage());

       }

       throw new EJBException

          ("Transaction failed: " + ex.getMessage());

    }

}

非提交返回事务

使用Bean管理事务的无状态会话Bean在事务返回前必须提交或者返回事务，而有状态的会话Bean没有这个限制。

对于使用JTA事务的有状态会话Bean，Bean实例和事务的关联越过大量用户调用被保持，甚至被调用的每个商业方法都打开和关闭数据库连接，该市无关联也不断开，直到事务完成（或回滚）。

对于使用JDBC事务的有状态会话Bean，JDBC连接越过用户调用保持Bean和事务之间的关联。连接关闭，事务关联将被释放。

在Bean管理事务中不允许使用的方法

在Bean管理的事务中不能调用EJBContext接口的getRollbackOnly和setRollbackOnly方法，这两个方法只能在容器管理事务中被调用。在Bean管理事务中，应调用UserTransaction接口的getStatus和rollback方法。

四．企业Bean事务摘要

如果你不能确定怎么在企业Bean中使用事务，可以用这个小技巧：在Bean的部署描述符中，制定事务类型为容器管理，把整个Bean（所有方法）的事务属性设置为Required。大多数情况下，这个配置可以满足你的事务需求。

表14-2列出了不同类型的企业Bean所允许使用的事务类型。实体Bean只能使用容器管理事务，但可以在部署描述符中配置事务属性，并可以调用EJBContext接口的setRollbackOnly方法来回滚事务。

会话Bean既可以使用容器管理事务也可以使用Bean管理事务。Bean管理事务又有两种类型：JDBC事务和JTA事务。JDBC事务使用Connection接口的commit和rollback方法来划分事务界限。JTA事务使用UserTransaction接口的begin、commit和rollback方法来划分事务界限。

在Bean管理事务的会话Bean中，混合使用JTA事务和JDBC事务是可能的。但是我不推荐这样使用，因为这样会造成代码的调试和维护都很困难。

Message-driver Bean和会话Bean一样既可以使用容器管理事务也可以使用Bean管理事务。

五．事务超时

对于容器管理事务，事务超时间隔是通过设置default.properties文件中ransaction.timeout属性的值来确定的，该文件在J2EE SDK安装目录的config子目录下。如下例将事务超时间隔设置为5秒钟：

transaction.timeout=5

这样，当事务在5秒钟内还没有完成，容器将回滚该事务。

J2EE SDK安装后，超时间隔的缺省值为0，表示不计算超时，无论事务执行多长时间，除非异常出错回滚，一直等待事务完成。

只有使用容器管理事务的企业Bean才会受到transaction.timeout属性值的影响。Bean管理的JTA事务使用UserTransaction接口的setTransactionTimeout方法来设置事务超时间隔。

六．隔离级别

事务不仅保证事务界限内的数据库操作全部完成（或回滚）同时还隔离数据库更新语句。隔离级别描述被修改的数据对其他事物的可见度。

假如一个应用程序在事务中修改一个顾客的电话号码，在事务结束前另一个应用程序要读取该条记录的电话号码。那么第二个应用程序是读取修改过但还没提交的数据，还是读取未修改前的老数据呢？答案就取决于事务的隔离级别。如果事务允许其他程序读取未提交的数据，会因为不用等待事务结束而提高性能，同时也有一个缺点，如果事务回滚，其他应用程序读取的将是错误的数据。

容器管理持久性（CMP）的实体Bean的事务级别无法修改，它们使用DBMS的默认个理解别，通常是READ_COMMITTED。

Bean管理持久性（BMP）的实体Bean和两种会话Bean都可以通过在程序中调用底层DBMS提供的API来设置事务级别。例如，一个DBMS可能允许你如下调用setTransactionIsolation方法将隔离级别设置成可读取未提交数据：

Connection con;

...

con.setTransactionIsolation(TRANSACTION_READ_UNCOMMITTED);

不要在事务执行期间更改隔离级别，通常隔离级别的更改会引起DBMS产生一次隐式提交。因为隔离级别的控制会跟具体的DBMS厂商不同而不同，具体的信息请参考DBMS的文档。J2EE平台规范不包括隔离级别标准。

七．更新多个数据库

J2EE事务管理器控制着除了Bean管理的JDBC事务以外的所有企业Bean事务，它允许企业Bean在同一个事务中更新多个数据库。下面示范在单个事务中更新多个数据库的两个应用。

图14-2中，客户端调用Bean-A的商业方法，商业方法启动一个事务，更新数据库X和Y，Bean-A的商业方法有调用Bean-B的商业方法，Bean-B的商业方法更新数据库Z然后返回事务的控制权给Bean-A的商业方法，由Bean-A提交该事务。三个数据库的更新都在同一个事务中发生。

图 14-2 更新多个数据库

图14-3中，客户端调用Bean-A的商业方法，该商业方法启动一个事务并更新数据库X，然后调用另一个J2EE服务器中的Bean-B的方法，该方法更新数据库Y。J2EE服务器保证两个数据库的更新都在同一个事务中进行（笔者认为应该是第一个J2EE服务器的事务管理器管理整个事物）。

图 14-3 跨越J2EE服务器更新多个数据库

八．Web 组件事务

Web组件中划分事务界限可以使用java.sql.Connection接口和javax.transaction.UserTransaction接口中的任意一个。跟Bean管理事务的会话Bean使用一样的两个接口。这两个接口的使用方法参考前面几节的内容。Web组件事务的例子在第10章Servlet技术第四节共享信息的访问数据库小节讲述过。

优质管理的四大要素：
    选择正确的人。
    为他们分配正确的工作。
    保持他们的积极性。
    帮助团队凝聚起来并保持团队的凝聚力。
    (其他一切都只是"文案"。)

安全和变化
    除非感到安全，否则人们就不能去迎接变化。
    在所有成功的工程中(以及在绝大多数其他有价值的工作中)，变化都是基本的要素之一。
    安全感的缺乏会让人们反对变化。
    逃避风险是致命的，因为这会让你也得不到与风险同在的利益。
    人们可能会因为来自客观世界的直接的恐吓而觉得没有安全感，但是如果察觉到管理者可能滥用权力来惩罚自己，他们也会觉得没有安全感。

负面效应
    威胁不是提高业绩最好的方法。
    如果分配的时间一开始就不够，不管威胁有多么吓人，工作也无法按时完成。
    更糟糕的是，如果目标没有实现，你就必须兑现你的威胁。

管理者必需的身体部位
    管理涉及到心、肠胃、灵魂和鼻子。
    因此……用心来领导，相信你的肠胃(相信你的预感)，构筑团队的灵魂，训练一个能嗅出谎言的鼻子。

用指挥战争来作为管理的一个比喻
    在战役开始的时候，管理者真正的工作已经完成了。

面试和招聘
    招聘涉及到所有与管理相关的身体部位：心、灵魂、鼻子和肠胃(但是主要是肠胃)。
    不要试图单独去招聘——两副肠胃远比一副肠胃的两倍要好。
    对于新的雇员，让他们承担与以前曾经成功过的同样难度的项目，把有挑战性的目标推迟到下一次。
    征求提示：你最希望雇的那个人可能还知道其他很好的人选。
    多听，少说。
    如果先把材料整理好，那么所有的事情都会进行得更好。

生产力的提高
    没有"短期生产力提高"这样的东西。
    生产力的提高是来自长期投资的。
    任何承诺立刻见效的东西都很可能是江湖游医所卖的万灵油。

风险控制
    通过控制风险来管理项目。
    为每个项目创建并维护风险统计表。
    跟踪根源性的风险，而不只是最后那讨厌的结果。
    评估每种风险具体化的概率和可能造成的开销。
    对于每种风险，预测标志其具体化的早期征兆。
    任命一个风险控制官，这个人不应该维护组织内部"我能行"的态度。
    建立简单的(可能是匿名的)通道，让坏消息能传递到高层。

防止失败
　    壮士断腕。
　    控制住失败比优化成功更能提高你全面的成绩。
　    要有闯劲，尽早取消失败的工作。
　    除非必要，否则就不要自己去凝聚一个团队：出去找一个已经成型的团队来用。
　    保持好的团队在一起(只要他们自己愿意)，以帮助你的继任者避免团队凝聚得慢或者不能凝聚的问题。
　    把凝聚在一起的团队--准备好、并且也愿意接受新的工作--作为项目的收获之一。
　    项目开始时浪费的一天和最后阶段浪费的一天对项目造成的伤害是同等的。
    有无数种方法可以浪费一天的时间……但是没有任何一种方法可以拿回一天的时间。

开发过程的建模和模拟
　    将你关于完成工作过程的直觉建模。
　    在同事的交流中使用这些模型，以便交流、提炼关于项目运转的思想。
　    用模型来模拟项目的结果。
　    根据实际的结果来调整模型。

"病态的政治"
    每一天，你都必须准确度拿自已的工作去打赌......
    ......但是这也不能保证"病态的政治"不会影响你。
    "病态的政治"可能在任何地方出现，哪怕是在最健康的组织里面。
    "病态的政治"的特征：对个人权势的渴望超过了组织本身的目标。
    即使这种不合理的目标与组织的目标背道而驰，它也可能出现。
    "病态的政治"的副作用：它使精简的项目变得危险。

度量
    度量每个产品的规模。
    不要执着于单位——在等待客观度量的时候，先用你自己的主观单位。
    从所有能得到的原始数据(可计算的软件特征)自己构造度量单位。
    不断完善你的度量方程式，直到它的计算结果与原始数据库中的项目工作量有最好的对应关系。
    借助数据库画一条趋势线，把预期的工作量作为人造度量单位值的函数显示出来。
    现在，针对每个要度量的项目，计算出人造度量单位值，并根据这个值在趋势线上找到预期工作量值。
    用生产力趋势周围的干扰水平作为映射的公差指示。

过程和过程改进
    好的过程和持续的过程是绝好的目标。
    它们也是非常自然的目标：优秀的技术工作者一定会关注它们，而不管你是否告诉他们。
    正式的过程改进程序需要花钱、花时间；特定的过程改进工作还会延缓项目进度。尽管最终体现出生产力上的收获，它们也不可能抵消花在过程改进上的时间。
    但是项目有希望从单个的、正确选择的方法改进中得到足够的收益，并赢回为这次改变付出的时间和金钱。
    在项目进行过程中，不要希望在超过一个地方的范围内实施必改进。多种技术的改进程序（比如说提高整整一个CMM等级)很可能让项目比不实施这些程序完成得更晚。
    标准过程的危险就在于人们可能失去重要的走捷径的机会。
    特别是对于人员超编的项目，标准的过程看去会很严谨，因为它们制造出了足够的工作（有用的和无用的），让所有人都忙于不停。

改变完成工作的方式
    如果不大幅减少调试时间，就没有办法让项目大幅度提前完成。
    高速完成的项目用在调试上的时间成比例地少得多。
    高速完成的项目用在设计上的时间也成比例地多得多。
    如果你不关心别人， 不照顾别人，就别想让他们做一些不同寻常的事情。如果要让他们改变，就必须去了解（并赞赏）他们的过去。

压力的效果
    压力之下的人无法更快的思考。
    增加加班时间只会降低生产力。
    短期的压力乃至于加班可能是有用的策略，因为它们能使员工集中精力，并且让他们感到工作的重要性。但是长期的压力肯定是错误的。
    经理们之所以会施加那么多压力，也许是因为他们不知道该做什么，或者因为其他办法的困难而感到气馁。
    最坏的猜想：使用压力和加班的真正原因是为了在项目失败的时候让所有人看上去能好一点。
   
愤怒的经理
    管理中的愤怒和羞辱是会传染的。如果高级管理者喜欢骂人，低级管理者也会有样学样（就象经常被骂的小孩很容易变成爱骂人的父母）。
    管理中的辱骂常被认为是一种刺激，可以让员工提高效率。在" 胡萝卜加大棒"的管理策略中，辱骂是最常见的"大棒"。但是，哪有人被辱骂之后还能做得更好的？
    如果经理使用辱骂的方法来刺激员工，这就表现经理的无能，而不是员工的无能。

含糊的规格文档
    规格文档中的含糊标志着不同的系统参与者之间存在未解决的冲突。
    如果一份规格文档不包含完整的输入输出列表，那么它就是毫无希望的：它根本就没有开始说明任何东西。
    没有人会告诉你一份规格文档是不是糟糕。人们往往倾向于责备自己，而不责备文档。

冲突
    只要在开发过程中有多个参与者，就一定会有冲突存在。
    创建、安装系统的业务中特别容易出现冲突。
    绝大多数系统开发团队都缺乏解决冲突的能力。
    冲突应当引起重视。冲突并不是缺乏职业道德的行为。
    应当提前声明：所有人的"赢"都是受重视的。确保每个级别的人都能赢。
    谈判困难，调解容易。
    如果两个人的利益是完全或者部分相斥的，预先做好安排，准备好请双方通过调解来解决冲突。
    记住：我们都站在同一边；跟我们对立的，是我们要解决的问题。
   
催化剂的角色
    有这样一种催化剂式的人格。这样的人会帮助团队成型并凝聚，保持团队的健康和生产力，从而对项目作出贡献。就算"催化剂"别的什么都不干（其实，通常他们还会干很多别的事），这种催化剂的角色也是重要而有价值的。
    调解是"催化剂"的一项特殊工作。调解是可以学的，而且只需要很小的投资就能学会。
    调解应该从一个小小的仪式开始。"我能帮你们调解一下吗？"在解决冲突的时候，这是必要的第一个步骤。

人类的错误
    将你置于死的，不是你不知道的东西……而正是你"知道"绝不会置你于死地的东西。

人员安排
    在早期，人员超编会迫使项目跨过关键的设计阶段（这是为了让所有的人都有事可做）。
    如果在设计完成之前， 工作先被分给了许多人，那么人与人之间、工作与工作之间的接口就会很复杂。
    这会使团队内部耦合度提高，会议时间、重复劳动和无效的工作都会增加。
    理想的人员安排是这样的：在项目的大部分时间内由小型核心团队来做设计工作，在开发的最后阶段（时间安排的最后1/6）加入大量的人手。
    可怕的猜想：时间安排紧迫的项目，与时间安排比较合理的项目比起来，完成的时间反而会更长。

项目社会学
    让不必与会的人可以放心离开，从而保持会议的精简。有一份公开的议程，并严格执行，这是最简单的办法。
    项目需要仪式。
    用小小的仪式来使人们注意项目的目标的理想状态：小规模会议、零缺陷工作等等。
    采取行动，防止人们随便发怒。
    记住：愤怒=恐惧。随便对下级发怒的经理一定是因为恐惧才会这样做的。
    意见：如果所有人都懂得"愤怒=恐惧"这个道理，就能明显看出发怒的人是在害怕。由于无法隐瞒自己的恐惧，他也就不会再生气了。（这不能解决这些生气的人的问题，但是肯定可以让其他人好受一些。）
   
"病态的政治"(旧话重提)
    别想根治一个病态的人。
    不要浪费时间，也不要因为尝试治疗上司的病态而使自己受到威胁。
    有时候，你唯一的的选择就是等待，等问题自己解决，或者等一个让你继续前进的机会。
    奇迹是有可能发生的(但是千万别去指望它)。

精兵简政
    精兵简政是失败公司使用的办法，它使员工负但失败的责任。
    公司的目标应该正好相反：兴旺而人性化。
    当你听到"精兵简政"这个词的时候，请记住它的弦外之音：失败和恐吓。

基本常识
    项目既需要目标，也需要计划。
    而且这两者应该不同。

   在jsp规范里，标签具有比javabean更丰富的运行时协议。它可以非常机密的和jsp的表示逻辑联系在一起，同时，又具有javabean相同业务处理能力。所以，标签的学习成为迫切的需要，但为了满足实际项目的开发，自定义标签的学习是不容错过的。

   通过实现接口或者继承现有的类，我们就可以开发自定义的标签。

   常用的接口有：             JspTag

                       Tag       SimpleTag<----SimpleTagSupport

               IterationTag <----TagSupport           

                    BodyTag<----BodyTagSupport

   自定义标签的开发包括两个部分的开发：

（1）、开发标签的处理程序（java类）

（2）、标签描述文件（.tld文件）

   自定义标签的种类有许多，可以根据实际项目的需要进行编写。但为了不重复的开发轮子，jsp标准推出JSTL（标准标签库）。

   开始我们的旅行吧，只要是快乐的，谁都想干，做的好与不好就另当别论了。

（1）从Hello World开始吧，自定义一个类它实现Tag接口，Tag接口主要定义的是标签声明周期的方法，比如：doStartTag()，doEndTag()等，通过PageContext对象来访问Jsp页面的上下文：

package com.xmddl.tag.demo;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.PageContext;
import javax.servlet.jsp.tagext.Tag;

public class HelloTag implements Tag {
 private PageContext context;
 private Tag parent;
 public void setPageContext(PageContext ctx) {
  this.context=ctx;

 }

 public void setParent(Tag tag) {
  this.parent=tag;

 }

 public Tag getParent() {
  return this.parent;
 }

 public int doStartTag() throws JspException {
  System.out.println("doStartTag");
  return Tag.SKIP_BODY;
 }

 public int doEndTag() throws JspException {
  System.out.println("doStartTag");
  try {
   this.context.getOut().write("Hello World");
  } catch (Exception e) {
   e.printStackTrace();
  }
  return Tag.EVAL_PAGE;
 }

 public void release() {
  // TODO Auto-generated method stub
 }

}

 Tag接口中静态常量：

Tag.SKIP_BODY

Tag.EVAL_PAGE

Tag.EVAL_BODY_INCLUDE

Tag.SKIP_PAGE

（2）编写标签描述文件（.tld）：

<?xml version="1.0" encoding="UTF-8" ?>
<taglib xmlns=" http://java.sun.com/xml/ns/j2ee "
    xmlns:xsi=" http://www.w3.org/2001/XMLSchema-instance "
    xsi:schemaLocation=" http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd "
    version="2.0">

  <description>xmddl 1.1 hello library</description>
  <display-name>xmddl hello</display-name>
  <tlib-version>1.1</tlib-version>
  <short-name>hello</short-name>
  <uri>http://www.xmddl.com/tag</uri>
 
  <tag>
    <description>我的Hello World</description>
    <name>hello</name>
    <tag-class>com.xmddl.tag.demo.HelloTag</tag-class>
    <body-content>empty</body-content>
  </tag>

</taglib>

（3）、在web.xml中对标签的引用：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" " http://java.sun.com/dtd/web-app_2_3.dtd ">
<web-app>
 <taglib>
   <taglib-uri>http://www.xmddl.com/tag</taglib-uri>
  <taglib-location>/WEB-INF/mytag.tld</taglib-location>
 </taglib>
</web-app>

（4）、编写测试页面：

<%@ page language="java" pageEncoding="UTF-8" import="java.util.*"%>
<%@ taglib uri="http://www.xmddl.com/tag" prefix="lu"%>
<html>
  <head>
    <title>MyJsp.jsp</title>
    <meta http-equiv="pragma" content="no-cache">
    <meta http-equiv="cache-control" content="no-cache">
    <meta http-equiv="expires" content="0">   
    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    <meta http-equiv="description" content="This is my page">
  </head>
 
  <body>
    <h1>This is a test tag page for person.</h1> <br>
   <lu:hello/>
  </body>
</html>
下面看看标签中的属性是如何使用的，我们直接继承TagSupport类来编写：

 package com.xmddl.tag.demo;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.Tag;
import javax.servlet.jsp.tagext.TagSupport;

public class HelloSupport extends TagSupport {
 private String value;
 private static final long serialVersionUID = 1L;
 public HelloSupport(){
  super();
 }
 public int doStartTag() throws JspException {
  System.out.println("doStartTag");
  return TagSupport.EVAL_BODY_INCLUDE;
 }

 public int doEndTag() throws JspException {
  System.out.println("doEndTag");
  try {
   this.pageContext.getOut().write("标签的属性值："+this.value);
  } catch (Exception e) {
   e.printStackTrace();
  }
  return Tag.EVAL_PAGE;
 }
 public int doAfterBody() throws JspException{
  System.out.println("doAfterBody");
  try {
   this.pageContext.getOut().write("<br>以上为标签的内容<br>");
  } catch (Exception e) {
   e.printStackTrace();
  }
  return TagSupport.EVAL_BODY_INCLUDE;
  
 }
 public String getValue() {
  return value;
 }
 public void setValue(String value) {
  this.value = value;
 }
}
======================

...

<tag>
    <name>hellosupport</name>
    <tag-class>com.xmddl.tag.demo.HelloSupport</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <name>value</name>
        <required>true</required>
        <rtexprvalue>false</rtexprvalue>
    </attribute>
  </tag>

...

=======================

<%@ page language="java" pageEncoding="gb2312" import="java.util.*"%>
<%@ taglib prefix="lu" uri=" http://www.xmddl.com/tag " %>
<html>
  <head>
  </head>
  <body>

    <h1>This is a test tag page for person.</h1> <br>
  <lu:hellosupport value="red">xmddl</lu:hellosupport>
  </body>
</html>

 利用TagSupport带来很大的方便，只要重写其中的部分方法即可实现一个标签处理程序，以上开发的标签程序和JSTL1.1标签库一起使用时出现一些疑问，原来标签的uri=" http://java.sun.com/jsp/jstl/core "，但是，在如下的测试中会发现c:out中的值输不出来，所以，只能改为uri=" http://java.sun.com/jstl/core "，

<%@ page language="java" pageEncoding="gb2312" import="java.util.*"%>
<%@ taglib prefix="lu" uri=" http://www.xmddl.com/tag " %>
<%@ taglib prefix="c" uri=" http://java.sun.com/jstl/core " %>

<html>
  <head>
  </head>
  <body>

    <h1>This is a test tag page for person.</h1> <br>
    <%request.setAttribute("name","xmddl"); %>
    <%session.setAttribute("names","xmddls"); %>
   
  <lu:hellosupport value="red">xmddl</lu:hellosupport><hr>
  <c:forEach begin="1" end="5" step="1">
   name=<c:out value="${name}"></c:out>
   names=<c:out value="${names}"></c:out><br>
  </c:forEach>
  </body>
</html>
输出如下：

This is a test tag page for person.
xmddl
以上为标签的内容
标签的属性值：red

name=xmddl names=xmddls
name=xmddl names=xmddls
name=xmddl names=xmddls
name=xmddl names=xmddls
name=xmddl names=xmddls

接着看看迭代标签的开发，首先，我们关注的是接口IterationTag，还有它的实现类TagSupport，接口BodyTag对IterationTag的扩展，还有BodyTag的实现类BodyTagSupport。

package com.xmddl.tag.demo;

import java.io.IOException;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.BodyTagSupport;
public class MyIteratorSupport extends BodyTagSupport {
 private static final long serialVersionUID = 1L;
 public String count;
 public String strColor;
 private int cou;
 
 public void setCount(String count) {
  this.count = count;
  cou=Integer.parseInt(count);
 }
 
 public int doAfterBody() throws JspException {
  try {
   this.pageContext.getOut().write("<br>");
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  if(cou>1){
   cou--;
   return MyIteratorTag.EVAL_BODY_AGAIN;
  }else{
   return MyIteratorTag.SKIP_BODY;
  }
 }
 public int doStartTag() throws JspException {
  try {
   this.pageContext.getOut().write("<font color='"+this.strColor+"'>");
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  return MyIteratorTag.EVAL_BODY_INCLUDE;
 }

 public int doEndTag() throws JspException {
  try {
   this.pageContext.getOut().write("</font>");
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  return MyIteratorTag.EVAL_PAGE;
 }

 public int getCou() {
  return cou;
 }

 public void setCou(int cou) {
  this.cou = cou;
 }

 public String getCount() {
  return count;
 }

 public String getStrColor() {
  return strColor;
 }

 public void setStrColor(String strColor) {
  this.strColor = strColor;
 }

}
＝＝＝＝＝＝＝＝＝＝＝＝＝＝

。。。

<tag>
    <description>对颜色的设置</description>
    <name>myColor</name>
    <tag-class>com.xmddl.tag.demo.MyIteratorSupport</tag-class>
    <body-content>JSP</body-content>
    <attribute>
        <name>count</name>
        <required>true</required>
    </attribute>
    <attribute>
        <name>strColor</name>
        <required>false</required>
    </attribute>
   </tag>

。。。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝

<%@ page language="java" pageEncoding="gb2312" import="java.util.*"%>
<%@ taglib prefix="lu" uri="http://www.xmddl.com/tag" %>
<html>
  <head>
  </head>
  <body>

    <h1>This is a test tag page for person.</h1> <br>
    <lu:myColor count="3" strColor="blue">xmddl</lu:myColor>
  </body>
</html>

输出如下

This is a test tag page for person.

xmddl
xmddl
xmddl