呓语的博客

Java实用工具类库中的类java.util.Random提供了产生各种类型随机数的方法。它可以产生int、long、float、double以及Goussian等类型的随机数。这也是它与java.lang.Math中的方法Random()最大的不同之处，后者只产生double型的随机数。
　　类Random中的方法十分简单，它只有两个构造方法和六个普通方法。
　　构造方法：
　　(1)public Random()
　　(2)public Random(long seed)
　　Java产生随机数需要有一个基值seed，在第一种方法中基值缺省，则将系统时间作为seed。
　　普通方法：
　　(1)public synonronized void setSeed(long seed)
　　该方法是设定基值seed。
　　(2)public int nextInt()
　　该方法是产生一个整型随机数。
　　(3)public long nextLong()
　　该方法是产生一个long型随机数。
　　(4)public float nextFloat()
　　该方法是产生一个Float型随机数。
　　(5)public double nextDouble()
　　该方法是产生一个Double型随机数。
　　(6)public synchronized double nextGoussian()
　　该方法是产生一个double型的Goussian随机数。
　　例2 RandomApp.java。
　　//import java.lang.*;
　　import java.util.Random;

　　public class RandomApp{
　　　public static void main(String args[]){
　　　　Random ran1=new Random();
　　　　Random ran2=new Random(12345);
　　　　//创建了两个类Random的对象。
　　　　System.out.println("The 1st set of random numbers:");
　　　　System.out.println("\t Integer:"+ran1.nextInt());
　　　　System.out.println("\t Long:"+ran1.nextLong());
　　　　System.out.println("\t Float:"+ran1.nextFloat());
　　　　System.out.println("\t Double:"+ran1.nextDouble());
　　　　System.out.println("\t Gaussian:"+ran1.nextGaussian());
　　　　//产生各种类型的随机数
　　　　System.out.print("The 2nd set of random numbers:");
　　　　for(int i=0;i<5;i++){
　　　　　System.out.println(ran2.nextInt()+" ");
　　　　　if(i==2) System.out.println();
　　　　　//产生同种类型的不同的随机数。
　　　　　System.out.println();
　　　　}
　　　}
}

本章介绍Java的实用工具类库java.util包。在这个包中，Java提供了一些实用的方法和数据结构。例如，Java提供日期(Data)类、日历(Calendar)类来产生和获取日期及时间，提供随机数(Random)类产生各种类型的随机数，还提供了堆栈(Stack)、向量(Vector) 、位集合(Bitset)以及哈希表(Hashtable)等类来表示相应的数据结构。
　　图8.1给出了java.util包的基本层次结构图。下面我们将具体介绍其中几个重要的类。
　　　　　　　　　　　┌java.util.BitSet
　　　　　　　　　　　│java.util.Calendar
　　　　　　　　　　　│　　　　　　└java.util.GregorianCalendar
　　　　　　　　　　　│java.util.Date
　　　　　　　　　　　│java.util.Dictionary
　　　　　　　　　　　│　　　　　　└java.util.Hashtable
　　　　　　　　　　　│　　　　　　　　　　　　　└java.util.Properties
　　　　　　　　　　　│java.util.EventObject
　　　　　　　　　　　│java.util.ResourceBundle
　　　　　　　┌普通类┤　　　　　　├java.util.ListResourceBundle
　　　　　　　│　　　│　　　　　　└java.util.PropertyResourceBundle
　　　　　　　│　　　│java.util.Local
　　　　　　　│　　　│java.util.Observable
　　　　　　　│　　　│java.util.Random
　　　　　　　│　　　│java.util.StringTokenizer
　　　　　　　│　　　│java.util.Vector
　　　　　　　│　　　│　　　　　　└java.util.Stack
　　Java.util┤　　　└java.util.TimeZone
　　　　　　　│　　　　　　　　　　└java.util.SimpleTimeZone
　　　　　　　│　　　┌java.util.Enumeration
　　　　　　　├接　口┤java.util.EventListener
　　　　　　　│　　　└java.util.Observer
　　　　　　　│　　　┌java.util.EmptyStackException
　　　　　　　└异常类┤java.util.MissingResourceException
　　　　　　　　　　　│java.util.NoSuchElementException
　　　　　　　　　　　└java.util.TooManyListenersException
　　　　　　　图8.1 java.util包的基本层次结构

8.2 日期类Date

　　Java在日期类中封装了有关日期和时间的信息，用户可以通过调用相应的方法来获取系统时间或设置日期和时间。Date类中有很多方法在JDK1.0公布后已经过时了，在8.3中我们将介绍JDK1.0中新加的用于替代Date的功能的其它类。
　　在日期类中共定义了六种构造函数。
　　(1)public Date()
　　创建的日期类对象的日期时间被设置成创建时刻相对应的日期时间。
　　例 Date today=new Date()；//today被设置成创建时刻相对应的日期时间。
　　(2)public Date (long date)
　　long 型的参数date可以通过调用Date类中的static方法parse(String s)来获得。
　　例 long l=Date.parse("Mon 6 Jan 1997 13:3:00");
　　　　Date day=new Date(l);
　　//day中时间为1997年 1月6号星期一，13:3:00。
　　(3)public Date(String s)
　　按字符串s产生一日期对象。s的格式与方法parse中字符串参数的模式相同。
　　例 Date day=new Date("Mon 6 Jan 1997 13:3:00");
　　//day 中时间为1997年1月6号星期一，13:3:00.
　　(4)public Date(int year,int month,int date)
　　(5)public Date(int year,int month,int date,int hrs,int min)
　　(6)public Date(int year,int month,int date,int hrs,int min,int sec)
　　按给定的参数创建一日期对象。
　　参数说明：
　　year的值为：需设定的年份-1900。例如需设定的年份是1997则year的值应为97，即1997-1900的结果。所以Date中可设定的年份最小为1900；
　　month的值域为0～11，0代表1月，11表代表12月；
　　date的值域在1～31之间；
　　hrs的值域在0～23之间。从午夜到次日凌晨1点间hrs=0，从中午到下午1点间hrs=12；
　　min和sec的值域在0～59之间。
　　例 Date day=new Date(11,3,4);
　　//day中的时间为：04-Apr-11 12:00:00 AM
另外，还可以给出不正确的参数。
　　例　设定时间为1910年2月30日，它将被解释成3月2日。
　　Date day=new Date(10,1,30,10,12,34);
　　System.out.println("Day's date is:"+day);
　　//打印结果为：Day's date is:Web Mar 02 10:13:34 GMT+08:00 1910
　　下面我们给出一些Date类中常用方法。
　　(1)public static long UTC(int year,int month,int date,int hrs. int min,int sec)
　　该方法将利用给定参数计算UTC值。UTC是一种计时体制，与GMT(格林威治时间)的计时体系略有差别。UTC计时体系是基于原子时钟的，而GTMT计时体系是基于天文学观测的。计算中使用的一般为GMT计时体系。
　　(2)public static long parse(String s)
　　该方法将字符串s转换成一个long型的日期。在介绍构造方法Date(long date)时曾使用过这个方法。
　　字符串s有一定的格式，一般为：
　　(星期 日 年 时间GMT+时区)
　　若不注明时区，则为本地时区。
　　(3)public void setMonth(int month)
　　(4)public int getMonth()
　　这两个方法分别为设定和获取月份值。
　　获取的月份的值域为0～11，0代表1月，11代表12月。
　　(5)public String toString()
　　(6)public String toLocalString()
　　(7)public String toGMTString()
　　将给定日期对象转换成不同格式的字符串。它们对应的具体的格式可参看例子8.1。
　　(8)public int getTimezoneOffset()
　　该方法用于获取日期对象的时区偏移量。
　　例8.1中对上面介绍的Date类中的基本方法进行了具体的应用，并打印了相应的结果。由于使用了一些过时的方法，所以编译时会有警告信息。另外，由于本例中的时间表示与平台有关，不同的JDK版本对此处理不完全相同，因此不同版本的JDK执行本例的结果可能有细微差异。
　　例8.1 DateApp.java
　　import java.lang.System;
　　import java.util.Date;
　　public class DateApp{
　　　public static void main(String args[]){
　　　　Date today=new Date();
　　　　//today中的日期被设成创建时刻的日期和时间，假设创建时刻为1997年3月
　　　　//23日17时51分54秒。
　　　　System.out.println("Today's date is "+today);
　　　　//返回一般的时间表示法，本例中结果为
　　　　//Today's date is Fri May 23 17:51:54 1997
　　　　System.out.println("Today's date(Internet GMT)is:"
　　　　　+today.toGMTString());
　　　　//返回结果为GMT时间表示法，本例中结果为
　　　　//Today's date(Internet GMT)is: 23 May 1997 09:51:54:GMT
　　　　System.out.println("Today's date(Locale) is:"
　　　　　+today.toLocaleString());
　　　　//返回结果为本地习惯的时间表示法，结果为
　　　　//Today's date(Locale)is:05/23/97 17:51:54
　　　　System.out.println("Today's year is: "+today.getYear());
　　　　System.out.println("Today's month is: "+(today.getMonth()+1));
　　　　System.out.println("Today's date is: "+today.getDate());
　　　　//调用Date类中方法，获取年月日的值。
　　　　//下面调用了不同的构造方法来创建Date类的对象。
　　　　Date day1=new Date(100,1,23,10,12,34);
　　　　System.out.println("Day1's date is: "+day1);
　　　　Date day2=new Date("Sat 12 Aug 1996 13:3:00");
　　　　System.out.println("Day2's date is: "+day2);
　　　　long l= Date.parse("Sat 5 Aug 1996 13:3:00 GMT+0800");
　　　　Date day3= new Date(l);
　　　　System.out.println("Day3's date(GMT)is: "+day3.toGMTString());
　　　　System.out.println("Day3's date(Locale)is: "
　　　　　+day3.toLocaleString());
　　　　System.out.println("Day3's time zone offset is:"
　　　　　+day3.getTimezoneOffset());
　　　}
　　}

　　运行结果(JDK1.3版，与原文不同，原文是JDK1.0版)：
　　E:\java\tutorial\java01>java DateApp
　　Today's date is Thu Dec 27 17:58:16 CST 2001
　　Today's date(Internet GMT)is:27 Dec 2001 09:58:16 GMT
　　Today's date(Locale) is:2001-12-27 17:58:16
　　Today's year is: 101
　　Today's month is: 12
　　Today's date is: 27
　　Day1's date is: Wed Feb 23 10:12:34 CST 2000
　　Day2's date is: Fri Aug 12 13:03:00 CST 1996
　　Day3's date(GMT)is: 5 Aug 1996 05:03:00 GMT
　　Day3's date(Locale)is: 1996-8-5 13:03:00
　　Day3's time zone offset is:-480

　　E:\java\tutorial\java01>

8.3 日历类Calendar

　　在早期的JDK版本中，日期(Date)类附有两大功能：(1)允许用年、月、日、时、分、秒来解释日期：(2)允许对表示日期的字符串进行格式化和句法分析。在JDK1.1中提供了类Calendar来完成第一种功能，类DateFormat来完成第二项功能。dateFormat是java.text包中的一个类。与Date类有所不同的是，DateFormat类接受用各种语言和不同习惯表示的日期字符串。本节将介绍java.util包中的类Calendar及其它新增加的相关的类。
　　类Calendar是一个抽象类，它完成日期(Date)类和普通日期表示法(即用一组整型域如YEAR，MONTH，DAY，HOUR表示日期)之间的转换。
　　由于所使用的规则不同，不同的日历系统对同一个日期的解释有所不同。在JDK1.1中提供了Calendar类一个子类GregorianCalendar??它实现了世界上普遍使用的公历系统。当然用户也可以通过继承Calendar类，并增加所需规则，以实现不同的日历系统。
　　第GregorianCalendar继承了Calendar类。本节将在介绍类GregorianCalendar的同时顺带介绍Calendar类中的相关方法。
　　类GregorianCalendar提供了七种构造函数：
　　(1)public GregorianCalendar()
　　创建的对象中的相关值被设置成指定时区，缺省地点的当前时间，即程序运行时所处的时区、地点的当前时间。
　　(2)public GregorianCalendar(TimeZone zone)
　　创建的对象中的相关值被设置成指定时区zone，缺省地点的当前时间。
　　(3)public GregorianCalendar(Locale aLocale)
　　创建的对象中的相关值被设置成缺省时区，指定地点aLocale的当前时间。
　　(4)public GregorianCalendar(TimeZone zone,Local aLocale)
　　创建的对象中的相关值被设置成指定时区，指定地点的当前时间。
　　上面使用到的类TimeZone的性质如下：
　　TimeZone是java.util包中的一个类，其中封装了有关时区的信息。每一个时区对应一组ID。类TimeZone提供了一些方法完成时区与对应ID两者之间的转换。
　　(Ⅰ)已知某个特定的ID，可以调用方法
　　public static synchronized TimeZone getTimeZone(String ID)
来获取对应的时区对象。
　　例 太平洋时区的ID为PST，用下面的方法可获取对应于太平洋时区的时区对象：
　　TimeZone tz=TimeZone.getTimeZone("PST");
　　调用方法getDefault()可以获取主机所处时区的对象。
　　TimeZone tz=TimeZone.getDefault();
　　(Ⅱ)调用以下方法可以获取时区的ID
　　■public static synchronized String[] getavailableIDs(int rawOffset)
　　根据给定时区偏移值获取ID数组。同一时区的不同地区的ID可能不同，这是由于不同地区对是否实施夏时制意见不统一而造成的。
　　例String s[]=TimeZone.getAvailableIDs(-7*60*60*1000);
　　打印s，结果为s[0]=PNT，s[1]=MST
　　■public static synchronized String[] getAvailableIDs()
　　获取提供的所有支持的ID。
　　■public String getID()
　　获取特定时区对象的ID。
　　例 TimeZone tz=TimeZone.getDefault();
　　String s=tz.getID();
　　打印s，结果为s=CTT。
　　上面使用类的对象代表了一个特定的地理、政治或文化区域。Locale只是一种机制，它用来标识一类对象，Local本身并不包含此类对象。
　　要获取一个Locale的对象有两种方法：
　　(Ⅰ)调用Locale类的构造方法
　　Locale(String language,String country)
　　Locale(String language,String country,String variant)
　　参数说明：language??在ISO-639中定义的代码，由两个小写字母组成。
　　　　　　　country??在ISO-3166中定义的代码，由两个大写字母组成。
　　　　　　　variant??售货商以及特定浏览器的代码，例如使用WIN代表Windows。
　　(Ⅱ)调用Locale类中定义的常量
　　Local类提供了大量的常量供用户创建Locale对象。
　　例 Locale.CHINA
　　　　为中国创建一个Locale的对象。
　　类TimeZone和类Locale中的其它方法，读者可查阅API。
　　(5)public GregorianCalendar(int year,int month,int date)
　　(6)public GregorianCalendar(int year,int month,int date,int hour,int minute)
　　(7)public GregorianCalendar(int year,int month,int date,int hour,int minute,int second)
　　用给定的日期和时间创建一个GregorianCalendar的对象。
　　参数说明：
　　year-设定日历对象的变量YEAR；month-设定日历对象的变量MONTH；
　　date-设定日历对象的变量DATE；hour-设定日历对象的变量HOUR_OF_DAY；
　　minute-设定日历对象的变量MINUTE；second-设定日历对象的变量SECOND。
　　与Date类中不同的是year的值没有1900这个下限，而且year的值代表实际的年份。month的含义与Date类相同，0代表1月，11代表12月。
　　例 GregorianCalendar cal=new GregorianCalendar(1991,2,4)
　　cal的日期为1991年3月4号。
　　除了与Date中类似的方法外，Calendar类还提供了有关方法对日历进行滚动计算和数学计算。计算规则由给定的日历系统决定。进行日期计算时，有时会遇到信息不足或信息不实等特殊情况。Calendar采取了相应的方法解决这些问题。当信息不足时将采用缺省设置，在GregorianCalendar类中缺省设置一般为YEAR=1970,MONTH=JANUARY,DATE=1。
　　当信息不实时，Calendar将按下面的次序优先选择相应的Calendar的变量组合，并将其它有冲突的信息丢弃。
　　MONTH+DAY_OF_MONTH
　　MONTH+WEEK_OF_MONTH+DAY_OF_WEEK
　　MONTH+DAY_OF_WEEK_OF_MONTH+DAY_OF_WEEK
　　DAY_OF+YEAR
　　DAY_OF_WEEK_WEEK_OF_YEAR
　　HOUR_OF_DAY

8.4 随机数类Random

　　Java实用工具类库中的类java.util.Random提供了产生各种类型随机数的方法。它可以产生int、long、float、double以及Goussian等类型的随机数。这也是它与java.lang.Math中的方法Random()最大的不同之处，后者只产生double型的随机数。
　　类Random中的方法十分简单，它只有两个构造方法和六个普通方法。
　　构造方法：
　　(1)public Random()
　　(2)public Random(long seed)
　　Java产生随机数需要有一个基值seed，在第一种方法中基值缺省，则将系统时间作为seed。
　　普通方法：
　　(1)public synonronized void setSeed(long seed)
　　该方法是设定基值seed。
　　(2)public int nextInt()
　　该方法是产生一个整型随机数。
　　(3)public long nextLong()
　　该方法是产生一个long型随机数。
　　(4)public float nextFloat()
　　该方法是产生一个Float型随机数。
　　(5)public double nextDouble()
　　该方法是产生一个Double型随机数。
　　(6)public synchronized double nextGoussian()
　　该方法是产生一个double型的Goussian随机数。
　　例8.2 RandomApp.java。
　　//import java.lang.*;
　　import java.util.Random;

　　public class RandomApp{
　　　public static void main(String args[]){
　　　　Random ran1=new Random();
　　　　Random ran2=new Random(12345);
　　　　//创建了两个类Random的对象。
　　　　System.out.println("The 1st set of random numbers:");
　　　　System.out.println("\t Integer:"+ran1.nextInt());
　　　　System.out.println("\t Long:"+ran1.nextLong());
　　　　System.out.println("\t Float:"+ran1.nextFloat());
　　　　System.out.println("\t Double:"+ran1.nextDouble());
　　　　System.out.println("\t Gaussian:"+ran1.nextGaussian());
　　　　//产生各种类型的随机数
　　　　System.out.print("The 2nd set of random numbers:");
　　　　for(int i=0;i<5;i++){
　　　　　System.out.println(ran2.nextInt()+" ");
　　　　　if(i==2) System.out.println();
　　　　　//产生同种类型的不同的随机数。
　　　　　System.out.println();//原文如此
　　　　}
　　　}
　　}

　　运行结果：
　　E:\java01>java RandomApp
　　The 1st set of random numbers:
　　　　Integer:-173899656
　　　　Long:8056223819738127077
　　　　Float:0.6293638
　　　　Double:0.7888394520265607
　　　　Gaussian:0.5015701094568733
　　The 2nd set of random numbers:1553932502
　　-2090749135
　　-287790814
　　-355989640
　　-716867186
　　E:\java01>

8.5 向量类Vector

　　Java.util.Vector提供了向量(Vector)类以实现类似动态数组的功能。在Java语言中。正如在一开始就提到过，是没有指针概念的，但如果能正确灵活地使用指针又确实可以大大提高程序的质量，比如在C、C++中所谓“动态数组”一般都由指针来实现。为了弥补这点缺陷，Java提供了丰富的类库来方便编程者使用，Vector类便是其中之一。事实上，灵活使用数组也可完成向量类的功能，但向量类中提供的大量方法大大方便了用户的使用。
　　创建了一个向量类的对象后，可以往其中随意地插入不同的类的对象，既不需顾及类型也不需预先选定向量的容量，并可方便地进行查找。对于预先不知或不愿预先定义数组大小，并需频繁进行查找、插入和删除工作的情况，可以考虑使用向量类。
　　向量类提供了三种构造方法：
　　public vector()
　　public vector(int initialcapacity,int capacityIncrement)
　　public vector(int initialcapacity)
　　使用第一种方法，系统会自动对向量对象进行管理。若使用后两种方法，则系统将根据参数initialcapacity设定向量对象的容量(即向量对象可存储数据的大小)，当真正存放的数据个数超过容量时，系统会扩充向量对象的存储容量。参数capacityIncrement给定了每次扩充的扩充值。当capacityIncrement为0时，则每次扩充一倍。利用这个功能可以优化存储。
　　在Vector类中提供了各种方法方便用户使用：
　　■插入功能
　　(1)public final synchronized void addElement(Object obj)
　　将obj插入向量的尾部。obj可以是任何类的对象。对同一个向量对象，可在其中插入不同类的对象。但插入的应是对象而不是数值，所以插入数值时要注意将数值转换成相应的对象。
　　例 要插入一个整数1时，不要直接调用v1.addElement(1)，正确的方法为：
　　Vector v1=new Vector();
　　Integer integer1=new Integer(1);
　　v1.addElement(integer1);
　　(2)public final synchronized void setElementAt(object obj,int index)
　　将index处的对象设成obj，原来的对象将被覆盖。
　　(3)public final synchronized void insertElementAt(Object obj,int index)
　　在index指定的位置插入obj，原来对象以及此后的对象依次往后顺延。
　　■删除功能
　　(1)public final synchronized void removeElement(Object obj)
　　从向量中删除obj。若有多个存在，则从向量头开始试，删除找到的第一个与obj相同的向量成员。
　　(2)public final synchronized void removeAllElement()
　　删除向量中所有的对象。
　　(3)public final synchronized void removeElementlAt(int index)
　　删除index所指的地方的对象。
　　■查询搜索功能
　　(1)public final int indexOf(Object obj)
　　从向量头开始搜索obj ,返回所遇到的第一个obj对应的下标，若不存在此obj，返回-1。
　　(2)public final synchronized int indexOf(Object obj,int index)
　　从index所表示的下标处开始搜索obj。
　　(3)public final int lastIndexOf(Object obj)
　　从向量尾部开始逆向搜索obj。
　　(4)public final synchronized int lastIndexOf(Object obj,int index)
　　从index所表示的下标处由尾至头逆向搜索obj。
　　(5)public final synchronized Object firstElement()
　　获取向量对象中的首个obj。
　　(6)public final synchronized Object lastelement()
　　获取向量对象中的最后一个obj。
　　了解了向量的最基本的方法后，我们来看一下例8.3VectorApp.java。
　　例8.3 VectorApp.java。
　　import java.util.Vector;
　　import java.lang.*;//这一句不应该要，但原文如此
　　import java.util.Enumeration;
　　public class VectorApp{
　　　public static void main(String[] args){
　　　　Vector v1=new Vector();
　　　　Integer integer1=new Integer(1);
　　　　v1.addElement("one");
　　　　//加入的为字符串对象
　　　　v1.addElement(integer1);
　　　　v1.addElement(integer1);
　　　　//加入的为Integer的对象
　　　　v1.addElement("two");
　　　　v1.addElement(new Integer(2));
　　　　v1.addElement(integer1);
　　　　v1.addElement(integer1);
　　　　System.out.println("The vector v1 is:\n\t"+v1);
　　　　//将v1转换成字符串并打印
　　　　v1.insertElementAt("three",2);
　　　　v1.insertElementAt(new Float(3.9),3);
　　　　System.out.println("The vector v1(used method insertElementAt()) is:\n\t "+v1);
　　　　//往指定位置插入新的对象，指定位置后的对象依次往后顺延
　　　　v1.setElementAt("four",2);
　　　　System.out.println("The vector v1(used method setElementAt()) is:\n\t "+v1);
　　　　//将指定位置的对象设置为新的对象
　　　　v1.removeElement(integer1);
　　　　//从向量对象v1中删除对象integer1由于存在多个integer1所以从头开始
　　　　//找，删除找到的第一个integer1
　　　　Enumeration enum=v1.elements();
　　　　System.out.print("The vector v1(used method removeElement())is:");
　　　　while(enum.hasMoreElements())
　　　　System.out.print(enum.nextElement()+" ");
　　　　System.out.println();
　　　　//使用枚举类(Enumeration)的方法来获取向量对象的每个元素
　　　　System.out.println("The position of object 1(top-to-bottom):"
　　　　　+ v1.indexOf(integer1));
　　　　System.out.println("The position of object 1(tottom-to-top):"
　　　　　+v1.lastIndexOf(integer1));
　　　　//按不同的方向查找对象integer1所处的位置
　　　　v1.setSize(4);
　　　　System.out.println("The new vector(resized the vector)is:"+v1);
　　　　//重新设置v1的大小，多余的元素被行弃
　　　}
　　}
　　运行结果：
　　E:\java01>java VectorApp
　　The vector v1 is:
　　　　　[one, 1, 1, two, 2, 1, 1]
　　The vector v1(used method insertElementAt()) is:
　　　　　[one, 1, three, 3.9, 1, two, 2, 1, 1]
　　The vector v1(used method setElementAt()) is:
　　　　　[one, 1, four, 3.9, 1, two, 2, 1, 1]
　　The vector v1(used method removeElement())is:one four 3.9 1 two 2 1 1
　　The position of object 1(top-to-bottom):3
　　The position of object 1(tottom-to-top):7
　　The new vector(resized the vector)is:[one, four, 3.9, 1]
　　E:\java01>
　　从例8.3运行的结果中可以清楚地了解上面各种方法的作用，另外还有几点需解释。
　　(1)类Vector定义了方法
　　public final int size()
　　此方法用于获取向量元素的个数。它的返回值是向是中实际存在的元素个数，而非向量容量。可以调用方法capactly()来获取容量值。
　　方法：
　　public final synchronized void setsize(int newsize)
　　此方法用来定义向量大小。若向量对象现有成员个数已超过了newsize的值，则超过部分的多余元素会丢失。
　　(2)程序中定义了Enumeration类的一个对象
　　Enumeration是java.util中的一个接口类，在Enumeration中封装了有关枚举数据集合的方法。
　　在Enumeration中提供了方法hawMoreElement()来判断集合中是束还有其它元素和方法nextElement()来获取下一个元素。利用这两个方法可以依次获得集合中元素。
　　Vector中提供方法：
　　public final synchronized Enumeration elements()
　　此方法将向量对象对应到一个枚举类型。java.util包中的其它类中也大都有这类方法，以便于用户获取对应的枚举类型。

8.6 栈类Stack

　　Stack类是Vector类的子类。它向用户提供了堆栈这种高级的数据结构。栈的基本特性就是先进后出。即先放入栈中的元素将后被推出。Stack类中提供了相应方法完成栈的有关操作。
　　基本方法：
　　public Object push(Object Hem)
　　将Hem压入栈中，Hem可以是任何类的对象。
　　public Object pop()
　　弹出一个对象。
　　public Object peek()
　　返回栈顶元素，但不弹出此元素。
　　public int search(Object obj)
　　搜索对象obj,返回它所处的位置。
　　public boolean empty()
　　判别栈是否为空。
　　例8.4 StackApp.java使用了上面的各种方法。
　　例8.4 StackApp.java。
　　import java.lang.*;
　　import java.util.*;
　　public class StackApp{
　　　public static void main(String args[]){
　　　　Stack sta=new Stack();
　　　　sta.push("Apple");
　　　　sta.push("banana");
　　　　sta.push("Cherry");
　　　　//压入的为字符串对象
　　　　sta.push(new Integer(2));
　　　　//压入的为Integer的对象，值为2
　　　　sta.push(new Float(3.5));
　　　　//压入的为Float的对象，值为3.5
　　　　System.out.println("The stack is,"+sta);
　　　　//对应栈sta
　　　　System.out.println("The top of stack is:"+sta.peek());
　　　　//对应栈顶元素，但不将此元素弹出
　　　　System.out.println("The position of object Cherry is:"
　　　　+sta.search("cherry"));
　　　　//打印对象Cherry所处的位置
　　　　System.out.print("Pop the element of the stack:");
　　　　while(!sta.empty())
　　　　System.out.print(sta.pop()+" ");
　　　　System.out.println();
　　　　//将栈中的元素依次弹出并打印。与第一次打印的sta的结果比较，可看出栈
　　　　//先进后出的特点
　　　}
　　}
　　运行结果(略)

8.7 哈希表类Hashtable

　　哈希表是一种重要的存储方式，也是一种常见的检索方法。其基本思想是将关系码的值作为自变量，通过一定的函数关系计算出对应的函数值，把这个数值解释为结点的存储地址，将结点存入计算得到存储地址所对应的存储单元。检索时采用检索关键码的方法。现在哈希表有一套完整的算法来进行插入、删除和解决冲突。在Java中哈希表用于存储对象，实现快速检索。
　　Java.util.Hashtable提供了种方法让用户使用哈希表，而不需要考虑其哈希表真正如何工作。
　　哈希表类中提供了三种构造方法，分别是：
　　public Hashtable()
　　public Hashtable(int initialcapacity)
　　public Hashtable(int initialCapacity,float loadFactor)
　　参数initialCapacity是Hashtable的初始容量，它的值应大于0。loadFactor又称装载因子，是一个0.0到0.1之间的float型的浮点数。它是一个百分比，表明了哈希表何时需要扩充，例如，有一哈希表，容量为100，而装载因子为0.9，那么当哈希表90%的容量已被使用时，此哈希表会自动扩充成一个更大的哈希表。如果用户不赋这些参数，系统会自动进行处理，而不需要用户操心。
　　Hashtable提供了基本的插入、检索等方法。
　　■插入
　　public synchronized void put(Object key,Object value)
给对象value设定一关键字key,并将其加到Hashtable中。若此关键字已经存在，则将此关键字对应的旧对象更新为新的对象Value。这表明在哈希表中相同的关键字不可能对应不同的对象(从哈希表的基本思想来看，这也是显而易见的)。
　　■检索
　　public synchronized Object get(Object key)
　　根据给定关键字key获取相对应的对象。
　　public synchronized boolean containsKey(Object key)
　　判断哈希表中是否包含关键字key。
　　public synchronized boolean contains(Object value)
　　判断value是否是哈希表中的一个元素。
　　■删除
　　public synchronized object remove(object key)
　　从哈希表中删除关键字key所对应的对象。
　　public synchronized void clear()
　　清除哈希表
　　另外，Hashtalbe还提供方法获取相对应的枚举集合：
　　public synchronized Enumeration keys()
　　返回关键字对应的枚举对象。
　　public synchronized Enumeration elements()
　　返回元素对应的枚举对象。
　　例8.5 Hashtable.java给出了使用Hashtable的例子。
　　例8.5 Hashtalbe.java。
　　//import java.lang.*;
　　import java.util.Hashtable;
　　import java.util.Enumeration;
　　public class HashApp{
　　　public static void main(String args[]){
　　　　Hashtable hash=new Hashtable(2,(float)0.8);
　　　　//创建了一个哈希表的对象hash，初始容量为2，装载因子为0.8

　　　　hash.put("Jiangsu","Nanjing");
　　　　//将字符串对象“Jiangsu”给定一关键字“Nanjing”,并将它加入hash
　　　　hash.put("Beijing","Beijing");
　　　　hash.put("Zhejiang","Hangzhou");

　　　　System.out.println("The hashtable hash1 is: "+hash);
　　　　System.out.println("The size of this hash table is "+hash.size());
　　　　//打印hash的内容和大小

　　　　Enumeration enum1=hash.elements();
　　　　System.out.print("The element of hash is: ");
　　　　while(enum1.hasMoreElements())
　　　　　System.out.print(enum1.nextElement()+" ");
　　　　System.out.println();
　　　　//依次打印hash中的内容
　　　　if(hash.containsKey("Jiangsu"))
　　　　　System.out.println("The capatial of Jiangsu is "+hash.get("Jiangsu"));
　　　　hash.remove("Beijing");
　　　　//删除关键字Beijing对应对象
　　　　System.out.println("The hashtable hash2 is: "+hash);
　　　　System.out.println("The size of this hash table is "+hash.size());
　　　}
　　}

　　运行结果：
　　The hashtable hash1 is: {Beijing=Beijing, Zhejiang=Hangzhou, Jiangsu=Nanjing}
　　The size of this hash table is 3
　　The element of hash is: Beijing Hangzhou Nanjing
　　The capatial of Jiangsu is Nanjing
　　The hashtable hash2 is: {Zhejiang=Hangzhou, Jiangsu=Nanjing}
　　The size of this hash table is 2

　　Hashtable是Dictionary(字典)类的子类。在字典类中就把关键字对应到数据值。字典类是一个抽象类。在java.util中还有一个类Properties，它是Hashtable的子类。用它可以进行与对象属性相关的操作。

8.8 位集合类BitSet

　　位集合类中封装了有关一组二进制数据的操作。
　　我们先来看一下例8.6 BitSetApp.java。
　　例8.6 BitSetApp.java
　　//import java.lang.*;
　　import java.util.BitSet;
　　public class BitSetApp{
　　　private static int n=5;
　　　public static void main(String[] args){
　　　　BitSet set1=new BitSet(n);
　　　　for(int i=0;i<n;i++) set1.set(i);
　　　　//将set1的各位赋1，即各位均为true
　　　　BitSet set2= new BitSet();
　　　　set2=(BitSet)set1.clone();
　　　　//set2为set1的拷贝
　　　　set1.clear(0);
　　　　set2.clear(2);
　　　　//将set1的第0位set2的第2位清零
　　　　System.out.println("The set1 is: "+set1);
　　　　//直接将set1转换成字符串输出，输出的内容是set1中值true所处的位置
　　　　//打印结果为The set1 is:{1,2,3,4}
　　　　System.out.println("The hash code of set2 is: "+set2.hashCode());
　　　　//打印set2的hashCode
　　　　printbit("set1",set1);
　　　　printbit("set2",set2);
　　　　//调用打印程序printbit(),打印对象中的每一个元素
　　　　//打印set1的结果为The bit set1 is: false true true true true
　　　　set1.and(set2);
　　　　printbit("set1 and set2",set1);
　　　　//完成set1 and set2,并打印结果
　　　　set1.or(set2);
　　　　printbit("set1 or set2",set1);
　　　　//完成set1 or set2,并打印结果
　　　　set1.xor(set2);
　　　　printbit("set1 xor set2",set1);
　　　　//完成set1 xor set2,并打印结果
　　　}
　　　//打印BitSet对象中的内容
　　　public static void printbit(String name,BitSet set){
　　　　System.out.print("The bit "+name+" is: ");
　　　　for(int i=0;i<n;i++)
　　　　　System.out.print(set.get(i)+" ");
　　　　System.out.println();
　　　}
　　}

　　运行结果：
　　The set1 is: {1, 2, 3, 4}
　　The hash code of set2 is: 1225
　　The bit set1 is: false true true true true
　　The bit set2 is: true true false true true
　　The bit set1 and set2 is: false true false true true
　　The bit set1 or set2 is: true true false true true
　　The bit set1 xor set2 is: false false false false false

　　程序中使用了BitSet类提供的两种构造方法：
　　　　public BitSet();
　　　　public BitSet(int n);
　　参数n代表所创建的BitSet类的对象的大小。BitSet类的对象的大小在必要时会由系统自动扩充。
　　其它方法：
　　public void set(int n)
　　将BitSet对象的第n位设置成1。
　　public void clear(int n)
　　将BitSet对象的第n位清零。
　　public boolean get(int n)
　　读取位集合对象的第n位的值，它获取的是一个布尔值。当第n位为1时，返回true；第n位为0时，返回false。
　　另外，如在程序中所示，当把一BitSet类的对象转换成字符串输出时，输出的内容是此对象中true所处的位置。
　　在BitSet中提供了一组位操作，分别是：
　　public void and(BitSet set)
　　public void or(BitSet set)
　　public void xor(BitSet set)
利用它们可以完成两个位集合之间的与、或、异或操作。
　　BitSet类中有一方法public int size()来取得位集合的大小，它的返回值与初始化时设定的位集合大小n不一样，一般为64。

小结

　　本章我们介绍了Java的实用工具类库java.util中一些常用的类。java.util包中还有其它一些类。它们的具体用法用户可以自行查阅API。在下一章，我们将学习利用java.awt包进行窗口程序设计。在下章的例子中我们将使用到本章介绍的各种类。

public class A{
    public static void main(String args[]){
        System.out.println("Hello World");
    }
}

public class A {
    
    public static void main(String args[]){
        System.out.prin("Hello World");
                   
    }
}

---------------------------------------------
| Eclipse Platform                          |             --------
|                                           |  ---\       |      |
|  -----------------------   ------------   |==| _ |______| JDT  |
|  |Workbench            |   |          |   |==|   |      |      |
|  |                     |   |          |   |  ---/       --------
|  |                     |   |          |   |
|  |      ---------------|   |   Help   |   |
|  |      |       jface  |   |          |   |
|  |-----------          |   |          |   |
|  |  SWT     |          |   |          |   |
|  |          |          |   ------------   |
|  -----------------------                  |
|                            ------------   |             --------
|  ------------------        |          |   |  ---\       |      |
|  |Workspace       |        |          |   |==| _ |______| PDE  |
|  |                |        |   Team   |   |==|   |      |      |
|  ------------------        |          |   |  ---/       --------
|                            |          |   |
|                            ------------   |
---------------------------------------------

Eclipse Platform 就是一个房子, workbench,jface, swt, workspace, help, team,
jdt, pde都是基于这个平台的插件.

下面我介绍一下这些基础插件的基本功能:

*: workbench用来控制工作台, 负责控制工作台上包括菜单,视图,透视图等等的控制和
操作
*: SWT是一个类似AWT,SWING的java组件,是一个轻量级的组件,而且和awt,swing不同的
是,它底层实现不是基于jre,而是根据不同操作系统,有相应的动态链接库实现,所以作出
来的效果很专业, SWT主要用于workbench的ui绘制
*: jface是基于SWT的一个插件, 对SWT进行了封装, 封装实现了对话框, 视图等东东
*: workspace是用来控制工作区的,(有别于工作台), 包括对工作区内的项目的控制,删
除,添加,编译项目资源等等都由它来控制
*: help是一个eclipse帮助系统, eclipse的菜单->Help-> Help Content,就可以打开这
个帮助系统, 这个系统不是封闭的, 可以进行扩展(以后会介绍做eclipse帮助的插件)
*: team是一个cvs系统,可以和CVS server协调使用,进行版本控制
*: jdt 是 Java Development Tools, 开发java的插件
*: pde 是 plug-in development environment, 开发插件的平台

[plug-in 的基本结构]

每一个plug-in都用一个目录包起来, 而且起目录名也是有讲究的,比如plug-in的名字叫
edu.sjtu.bbs.eclipse,版本是1.0.0, 那这个目录名就是edu.sjtu.bbs.eclipse_1.0.0.

而且随便打开一个plugin目录,可以发现总有一个文件叫一个叫plugin.xml,这个文件对
于plugin来说十分重要, 它相当于定义了plugin的运行参数,没有这个,plugin无法启动,
就像你家的电冰箱如果不知道是用110V还是220V的,你也不敢乱往插座上插,所以总要有
个说明,这个说明就是plugin.xml. 至于这个文件有些什么具体结构,我想在以后介绍编
写插件的时候,我会详细介绍.

[什么是 feature]

feature是功能部件,它里面没有实际的运行的库,它只是eclipse用来管理plugins的一种
途径. 比如你家装了电灯,总要有开关控制把,比如大堂的灯有一个开关控制, 卧室的灯
也有一个开关控制, 它们分别用来控制灯的亮与灭.
同样,功能部件就是用来控制插件的启动与否. eclipse的update透视图可以设定各个功
能部件的启用或禁用状态, 所以你可以通过禁用功能部件,来禁止插件的启动. 这样有一
个好处,比如你装了很多插件在eclipse上,但是装的越多,加载就越多,启动也会变慢, 你
不信的话,可以玩玩wsad, 就知道我说的话不是假的了.
所以,我们可以把功能部件看作是插件或插件集合的开关, 用来控制插件的状态. 如果pl
ugins目录有插件没有被任何一个功能部件包络的话, 我称之为"野插件", 就是eclipse
启动,它也一定会启动, 就相当于没有开关, 电源一直连通一样.

当然,功能部件还有很多其他方面的用处,以后会有详细介绍.

• Vector 还是ArrayList，哪一个更好，为什么？

要回答这个问题不能一概而论，有时候使用Vector比较好；有时是ArrayList，有时候这两个都不是最好的选择。你别指望能够获得一个简单肯定答案，因为这要看你用它们干什么。下面有4个要考虑的因素：

(1)API

(2)同步处理

(3)数据增长性

(4)使用模式

下面针对这4个方面进行一一探讨

API
在由Ken Arnold等编著的《Java Programming Language》(Addison-Wesley, June 2000)一书中有这样的描述，Vector类似于ArrayList.。所有从API的角度来看这两个类非常相似。但他们之间也还是有一些主要的区别的。

同步性

Vector是同步的。这个类中的一些方法保证了Vector中的对象是线程安全的。而ArrayList则是异步的，因此ArrayList中的对象并不是线程安全的。因为同步的要求会影响执行的效率，所以如果你不需要线程安全的集合那么使用ArrayList是一个很好的选择，这样可以避免由于同步带来的不必要的性能开销。

数据增长

从内部实现机制来讲ArrayList和Vector都是使用数组(Array)来控制集合中的对象。当你向这两种类型中增加元素的时候，如果元素的数目超出了内部数组目前的长度它们都需要扩展内部数组的长度，Vector缺省情况下自动增长原来一倍的数组长度，ArrayList是原来的50%,所以最后你获得的这个集合所占的空间总是比你实际需要的要大。所以如果你要在集合中保存大量的数据那么使用Vector有一些优势，因为你可以通过设置集合的初始化大小来避免不必要的资源开销。

使用模式

在ArrayList和Vector中，从一个指定的位置（通过索引）查找数据或是在集合的末尾增加、移除一个元素所花费的时间是一样的，这个时间我们用O(1)表示。但是，如果在集合的其他位置增加或移除元素那么花费的时间会呈线形增长：O(n-i)，其中n代表集合中元素的个数，i代表元素增加或移除元素的索引位置。为什么会这样呢？以为在进行上述操作的时候集合中第i和第i个元素之后的所有元素都要执行位移的操作。这一切意味着什么呢？

这意味着，你只是查找特定位置的元素或只在集合的末端增加、移除元素，那么使用Vector或ArrayList都可以。如果是其他操作，你最好选择其他的集合操作类。比如，LinkList集合类在增加或移除集合中任何位置的元素所花费的时间都是一样的—O(1)，但它在索引一个元素的使用缺比较慢－O(i),其中i是索引的位置.使用ArrayList也很容易，因为你可以简单的使用索引来代替创建iterator对象的操作。LinkList也会为每个插入的元素创建对象，所有你要明白它也会带来额外的开销。

最后，在《Practical Java》一书中Peter Haggar建议使用一个简单的数组（Array）来代替Vector或ArrayList。尤其是对于执行效率要求高的程序更应如此。因为使用数组(Array)避免了同步、额外的方法调用和不必要的重新分配空间的操作。

http://forum.javaeye.com/viewtopic.php?p=17108&highlight=Serializable+generate+SessionImplementor+sessionImplementor%2C#17108

看了看。真是万分高兴，可能别人用了一个星期才解决的问题。我现在就可以不劳而获。惭愧啊。。

由于担心Hibernate自身提供的increment id generator有性能影响，我对increment进行了扩展，改为InMemoryIncrement:

InMemoryIncrement.java

代码:
//Declare Classes Import here,Do not use .* to import all the classes in package.
import java.io.Serializable;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;

import java.util.Map;
import java.util.HashMap;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import net.sf.hibernate.HibernateException;
import net.sf.hibernate.MappingException;
import net.sf.hibernate.dialect.Dialect;
import net.sf.hibernate.engine.SessionImplementor;
import net.sf.hibernate.type.Type;
import net.sf.hibernate.id.IdentifierGenerator;
import net.sf.hibernate.id.PersistentIdentifierGenerator;
import net.sf.hibernate.id.Configurable;

/**
* Hibernate high performence id generator extend IncrementGenerator.<br>
* This generator use ’select max(column) from table ’ to get id’s init value
* in first time.Then generate increment id in memory .
* <p>
* 原理:
* <li>使用long[]数组在内存中存储每个表的最大值，使用Map存储表名在数组中对应的索引值。
* <li>第一次访问某个表的id的最大值时会从数据库中取出并存放到long数组中，
* 同时在Map中保存索引值
* <li>第二次以后访问会首先从Map中读出索引值，根据索引值把long数组对应的值
* 加上递增步长并返回
* </p>
* @author fenghm
* @version $Revision$
*/
public final class InMemoryIncrement implements IdentifierGenerator, Configurable {

    private static final Log log = LogFactory.getLog(InMemoryIncrement.class);
    
    //存储最大值的数组的容量
    private static final int MAX_CAPACITY = 200;
    
    /**同步锁*/
    private static final Object lock = new Object();

    //存储表存储在数组中的索引值
    private static Map map = new HashMap();
    
    //递增步长，默认加1
    private int step = 1;
    
    //最大值数组
    private static long[] seqs = new long[MAX_CAPACITY];
    
    //最大值数组已经使用的容量
    private static int lastIndex;
    
    private String key;
    private String sql;
    private Connection connection;
    private Class returnClass;
    
    /**
     * (none java doc)
     * @see net.sf.hibernate.id.IdentifierGenerator#
     * generate(net.sf.hibernate.engine.SessionImplementor, java.lang.Object)
     */
    public Serializable generate(SessionImplementor session, Object object)
    throws SQLException, HibernateException {
        connection = session.connection();
        
        long seq = -1;
        
        //找到索引值
        int index = findIndex();
        
        //把最大值加1
        seqs[index] = seqs[index] + step;
        
        seq = seqs[index];
        
        return new Long(seq);
    }

    /**
     * 找到表中自动增长字段存储在数组中的索引值
     * @return 索引值
     */
    private int findIndex(){
        int index = 0;
        
        //首先中缓存中取出索引值
        Integer integer = (Integer)map.get(key);
        
        //如果没有找到就从数据库中读出最大值并进行cache
        if(null == integer){
            //double check lock
            synchronized(lock){
                integer = (Integer)map.get(key);
                if(null == integer){
                    long maxvalue = 1;
                    try{
                        maxvalue = getMaxvalue();
                    }catch(SQLException e){
                        log.error(e);
                    }
                    integer = new Integer(lastIndex++);
                    seqs[integer.intvalue()] = maxvalue;
                    map.put(key,integer);                
                }
            }
        }
        
        index = integer.intvalue();
        return index;
    }    
    
    /**
     * (none java doc)
     * @see net.sf.hibernate.id.Configurable#configure(net.sf.hibernate.type.Type,
     * java.util.Properties, net.sf.hibernate.dialect.Dialect)
     */
    public void configure(Type type, Properties params, Dialect d)
    throws MappingException {
        
        //取出table参数
        String table = params.getProperty("table");
        if (table == null){
            table = params.getProperty(PersistentIdentifierGenerator.TABLE);
        }
        //取出column参数
        String column = params.getProperty("column");
        if (column == null){
            column = params.getProperty(PersistentIdentifierGenerator.PK);
        }
        
        //表的sehcma参数
        String schema = params.getProperty(PersistentIdentifierGenerator.SCHEMA);
        
        returnClass = type.getReturnedClass();
        
        //取出step参数
        String stepvalue = params.getProperty("step");
        if(null != stepvalue && !"".equals(stepvalue.trim())){
            try{
                step = Integer.parseInt(stepvalue);
            }catch(Exception e){
                log.error(e);
            }
        }
        

        //构造存储在Map中的索引值的key name
        key = table + "_$_" + column;
        
        //根据参数构造取最大值的SQL
        sql = "select max(" + column + ") from ";
        if(null != schema){
            sql += schema + ".";
        }
        sql += table;
    }
    
    /**
     * 取指定表中id字段的最大值，不存在记录返回0
     * @return 最大值
     * @throws SQLException if sql error occurs.
     */
    private long getMaxvalue() throws SQLException {
        long maxvalue = 0;
        
        PreparedStatement st = connection.prepareStatement(sql);
        ResultSet rs = null;
        try {
            rs = st.executeQuery();
            if(rs.next()) {
                maxvalue = rs.getLong(1);
            }
            sql = null;
        }finally {
            if (rs != null){
                rs.close();
            }
            st.close();
        }
        return maxvalue;
    }



测试代码：
Data.java
代码:
public class Data {

    private long id;
    private String name;
    private String email;

    /**
     * @return
     */
    public String getEmail() {
        return email;
    }

    /**
     * @return
     */
    public long getId() {
        return id;
    }

    /**
     * @return
     */
    public String getName() {
        return name;
    }

    /**
     * @param string
     */
    public void setEmail(String string) {
        email = string;
    }

    /**
     * @param l
     */
    public void setId(long l) {
        id = l;
    }

    /**
     * @param string
     */
    public void setName(String string) {
        name = string;
    }
}


Data.hbm.xml
代码:
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
<hibernate-mapping package="com.kmview.test.hibernate.model">
   <class name="Data" table="data">
      <id name="id" type="long" column="id">
         <generator class="com.kmview.test.hibernate.Generator"/>
      </id>
      <property name="name" type="java.lang.String" length="20" column="name"/>
      <property name="email" type="java.lang.String" column="email"/>
   </class>
</hibernate-mapping>



ThreadMain.java
代码:

public class ThreadMain extends Thread {

    public static void main(String[] args) {
        try{
            Configuration cfg = new Configuration().configure();
            SchemaExport schema = new SchemaExport(cfg);      
            schema.create(false,true);  

            for(int i=0;i<100;i++){
                new ThreadMain().start();
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
    
    public void run(){
        try{
            for(int i=0;i<20;i++){
            Session session = HibernateSession.openSession();

            Data data = new Data();
            data.setName("sdfsfsdf");
            data.setEmail("sdflkas;lfdalsfjasljf@d.d");

            session.save(data);
        
            session.flush();
            HibernateSession.closeSession();
            }              
        }catch(Exception e){
            e.printStackTrace();
        }
              
    }
}


HibernateSession.java
代码:
public final class HibernateSession {

    private HibernateSession(){}
    
    //synchronized lock for getSessionFactory
    private static Object lock = new Object();
    
    //common log object
    private static Log log = LogFactory.getLog(HibernateSession.class);
    
    //Hibernate SessionFactory
    private static SessionFactory sessionFactory;
    
    //Implement Hibatenate ThreadLocal pattern
    private static final ThreadLocal session = new ThreadLocal();
    
    
    /**
     * 自动在ClassPath的根路径寻找hibernate.properties与hibernate.cfg.xml文件<br>
     * 并初始化SessionFactory
     * @return SessionFactory
     */
    private static SessionFactory buildSessionFactory(){
        SessionFactory factory = null;
        try{
            Configuration config = new Configuration();
            config = config.configure();
            
            factory = config.buildSessionFactory();
            log.info("ok,SessionFactory builded!");
        }catch(HibernateException e){
            log.error(e);    
        }
        return factory;
    }
      
    /**
     * 取得当前会话的Hibernae Session对象，并打开数据库连接
     * @return Hibernate Session Object for Data Access
     * @exception HibernateException throw HibernateException
     */
    public static Session openSession() throws HibernateException{
        Session s = (Session)session.get();
        if(null == s){
            getSessionFactory();            
            if(null != sessionFactory){
                s = sessionFactory.openSession();
                session.set(s);
            }else{
                log.error("Error,SessionFactory object is not inited!");                  
            }
        }else if(!s.isConnected()){
            s.reconnect();
        }
        return s;
    }
    
    /**
     * 关闭数据库连接，在每次Session用完的时候，应该马上调用closeSession，<br>
     * 以把数据库连接归还到数据库连接池中，提高并发性能。
     */
    public static void closeSession(){
        try{
            Session s = (Session)session.get();
            if(null != s && s.isConnected()){
                s.disconnect();        
            }            
        }catch(HibernateException e ){
            log.error(e);
        }
    }
    
    /**
     * 释放Hibernate Session对象，此方法应该在当前线程消亡之前调用。<br>
     * 例如：在Web应用中可以使用filter统一在最后进行调用<br>
     * <code><pre>
     * public class HibernateFilter extends HttpServlet implements Filter{
     *  private FilterConfig filterConfig;
     *  public void init(FilterConfig filterConfig){
     *     this.filterConfig = filterConfig;
     *  }
     *
     *  public void doFilter(ServletRequest request,ServletResponse response,    
     *                       FilterChain filterChain){
     *     try{
     *        filterChain.doFilter(request,response);
     *     } catch(ServletException sx){
     *        filterConfig.getServletContext().log(sx.getMessage());
     *     } catch(IOException iox){
     *        filterConfig.getServletContext().log(iox.getMessage());
     *     }finally{
     *        HibernateSession.releaseSession();      
     *     }
     *  }
     * }
     * </pre></code>
     * 在Hibernate的API文档提到,Session的close()方法不是必须要被调用的，<br>
     * 但disconnect()方法是必须的；所以此方法也不是必须要被调用的，但是<br>
     * closeSession()方法是必须的。
     * @exception HibernateException throw HibernateException
     */
    public static void releaseSession() throws HibernateException{
        Session s = (Session)session.get();
        session.set(null);
        if(null != s){
            s.close();
        }
    }
    
    /**
     * 设置SessionFactory,提供此方法是为了可以在外部初始化SessionFactory.
     * @param factory SessionFactory
     */
    public static void setSessionFactory(SessionFactory factory){
        if(null == sessionFactory){
            sessionFactory = factory;
        }
    }
    
    /**
     * 获取SessionFactory,第一次访问时会自动在ClassPath的根路径寻找<br>
     * hibernate.properties与hibernate.cfg.xml文件并初始化。
     * @return SessionFactory
     */
    public static SessionFactory getSessionFactory(){
        //Double check lock.
        if(null == sessionFactory){
            synchronized(lock){
                if(null == sessionFactory){
                    sessionFactory = buildSessionFactory();
                }
            }
        }
        return sessionFactory;
    }
}

从网上当了一个例子，发觉上传图片文件时图片文件中内容发生了变化，最大的变化时所有的FF变成了3F

也就是说输出时把字符当成有符号传送了？（是这样把？）

使用代码如下：

PrintWriter pw = new PrintWriter(new BufferedWriter(new

FileWriter((savePath==null? "" : savePath) + filename)));

while (i != -1 && !newLine.startsWith(boundary)) {

// 文件内容的最后一行包含换行字符

// 因此我们必须检查当前行是否是最

// 后一行

i = in.readLine(line, 0, 1280);

if ((i==boundaryLength+2 || i==boundaryLength+4)

&& (new String(line, 0, i).startsWith(boundary)))

pw.print(newLine.substring(0, newLine.length()-2));

else

pw.print(newLine);

newLine = new String(line, 0, i);

}

pw.close();

但是总是不行，后来我把PrintWriter用FileOutputStream替代,代码如下：

FileOutputStream pw=new FileOutputStream((savePath==null? "" : savePath) + filename);

//PrintWriter pw = new PrintWriter(new BufferedWriter(new

//FileWriter((savePath==null? "" : savePath) + filename)));

while (i != -1 && !newLine.startsWith(boundary)) {

// 文件内容的最后一行包含换行字符

// 因此我们必须检查当前行是否是最

// 后一行

i = in.readLine(line, 0, 1280);

if ((i==boundaryLength+2 || i==boundaryLength+4)

&& (new String(line, 0, i).startsWith(boundary)))

pw.write(newLine.substring(0, newLine.length()-2).getBytes("ISO8859_1"));

else

pw.write(newLine.getBytes("ISO8859_1"));

newLine = new String(line, 0, i,"ISO8859_1");

}

pw.close();

竟然就可以了，那个转换的编码还一定要上才行，不然也不干活的，真是郁闷，这跨平台就不能让写CODE的人解放解放，一个输出都N多类，看着心寒，想着简直想死啊

哎 忙了我一个下午，原来就是这回事

下面把原代码附上，是把别人的代码改吧改吧放上来的，还请原作者不要见意：

Java bean 文件：

package cr.web;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.ServletInputStream;

import java.util.Dictionary;

import java.util.Hashtable;

import java.io.PrintWriter;

import java.io.BufferedWriter;

import java.io.FileWriter;

import java.io.IOException;

import java.io.*;

public class FileUploadBean {

private String savePath, filepath, filename, contentType;

private byte[] b;

byte t;

private Dictionary fields;

public String getFilename() {

return filename;

}

public String getFilepath() {

return filepath;

}

public void setSavePath(String savePath) {

this.savePath = savePath;

}

public String getContentType() {

return contentType;

}

public String getFieldValue(String fieldName) {

if (fields == null || fieldName == null)

return null;

return (String) fields.get(fieldName);

}

private void setFilename(String s) {

if (s==null)

return;

int pos = s.indexOf("filename=\"");

if (pos != -1) {

filepath = s.substring(pos+10, s.length()-1);

// Windows浏览器发送完整的文件路径和名字

// 但Linux/Unix和Mac浏览器只发送文件名字

pos = filepath.lastIndexOf("\\");

if (pos != -1)

filename = filepath.substring(pos + 1);

else

filename = filepath;

}

}

private void setContentType(String s) {

if (s==null)

return;

int pos = s.indexOf(": ");

if (pos != -1)

contentType = s.substring(pos+2, s.length());

}

public void getByte(HttpServletRequest request)

{

DataInputStream is;

int i=0;

try

{

is=new DataInputStream(request.getInputStream());

b=new byte[request.getContentLength()];

while (true)

{

try

{

t=is.readByte();

b[i]=t;

i++;

}

catch(EOFException e)

{ break;}

}

is.close();}

catch(IOException e)

{}

}

public void doUpload1(HttpServletRequest request) throws

IOException {

byte[] line=new byte[128];

FileOutputStream os=new FileOutputStream("c:\\Demo.out");

ServletInputStream in = request.getInputStream();

getByte(request);

String temp="";

temp=new String(b,"ISO8859_1");

byte[] img=temp.getBytes("ISO8859_1");

for (int i=0;i<img.length;i++)

{ os.write(img[i]); }

os.close();

}

public void doUpload(HttpServletRequest request) throws IOException {

request.setCharacterEncoding("GB2312");

ServletInputStream in = request.getInputStream();

byte[] line = new byte[1280];

int i = in.readLine(line, 0, 1280);

if (i < 3)

return;

int boundaryLength = i - 2;

String boundary = new String(line, 0, boundaryLength); //-2丢弃换行字符

fields = new Hashtable();

while (i != -1) {

String newLine = new String(line, 0, i);

if (newLine.startsWith("Content-Disposition: form-data; name=\"")) {

if (newLine.indexOf("filename=\"") != -1) {

setFilename(new String(line, 0, i-2));

if (filename==null)

return;

//文件内容

i = in.readLine(line, 0, 1280);

setContentType(new String(line, 0, i-2));

i = in.readLine(line, 0, 1280);

//空行

i = in.readLine(line, 0, 1280);

newLine = new String(line, 0, i,"ISO8859_1");

FileOutputStream pw=new FileOutputStream((savePath==null? "" : savePath) + filename);

//PrintWriter pw = new PrintWriter(new BufferedWriter(new

//FileWriter((savePath==null? "" : savePath) + filename)));

while (i != -1 && !newLine.startsWith(boundary)) {

// 文件内容的最后一行包含换行字符

// 因此我们必须检查当前行是否是最

// 后一行

i = in.readLine(line, 0, 1280);

if ((i==boundaryLength+2 || i==boundaryLength+4)

&& (new String(line, 0, i).startsWith(boundary)))

pw.write(newLine.substring(0, newLine.length()-2).getBytes("ISO8859_1"));

else

pw.write(newLine.getBytes("ISO8859_1"));

newLine = new String(line, 0, i,"ISO8859_1");

}

pw.close();

}

else {

// 普通表单输入元素

// 获取输入元素名字

int pos = newLine.indexOf("name=\"");

String fieldName = newLine.substring(pos+6, newLine.length()-3);

i = in.readLine(line, 0, 1280);

i = in.readLine(line, 0, 1280);

newLine = new String(line, 0, i);

StringBuffer fieldValue = new StringBuffer(1280);

while (i != -1 && !newLine.startsWith(boundary)) {

// 最后一行包含换行字符

// 因此我们必须检查当前行是否是最后一行

i = in.readLine(line, 0, 1280);

if ((i==boundaryLength+2 || i==boundaryLength+4)

&& (new String(line, 0, i).startsWith(boundary)))

fieldValue.append(newLine.substring(0, newLine.length()-2));

else

fieldValue.append(newLine);

newLine = new String(line, 0, i);

}

fields.put(fieldName, fieldValue.toString());

}

}

i = in.readLine(line, 0, 1280);

}

}

}

HTML页面：

<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=gb2312">

<title>文件上载</title>

</head>

<body>

<form action=jsp1.jsp enctype="MULTIPART/FORM-DATA" method=post>

作者: <input type=text name=author>

<br>

公司: <input type=text name=company>

<br>

说明: <textarea name=comment></textarea>

<br>

选择要上载的文件<input type=file name=filename>

<br>

文件描述: <input type=text name=description>

<br>

<input type=submit value="Upload">

</form>

</body>

</html>

JSP页面：

<%@ page contentType="text/html;charset=gb2312"%>

<jsp:useBean id="TheBean" scope="page" class="cr.web.FileUploadBean" />

<%

TheBean.setSavePath("d:\\");

//TheBean.doUpload1(request);

TheBean.doUpload(request);

out.println("Filename:" + TheBean.getFilename());

out.println("<BR>内容类型:" + TheBean.getContentType());

out.println("<BR>作者:" + TheBean.getFieldValue("Author"));

out.println("<BR>公司:" + TheBean.getFieldValue("Company"));

out.println("<BR>说明:" + TheBean.getFieldValue("Comment"));

%>

用户定义类型

单值类型是与现存类型（它的“源”类型）共享其内部表示的用户定义数据类型，但对于大多数运算来说，认为单值类型是独立和不兼容的。例如，您可能想定义年龄类型、重量类型以及高度类型，所有这些类型都有相当不同的语义，但都使用内部数据类型 INTEGER 作为它们的内部表示。

下列示例说明了命名为 PAY 的单值类型的创建：

     CREATE DISTINCT TYPE PAY AS DECIMAL(9,2) WITH COMPARISONS

虽然 PAY 有与内部数据类型 DECIMAL(9,2)相同的表示，但还是认为它是与 DECIMAL(9,2)或任何其他类型不可比的独立类型。它只能与相同的单值类型比较。并且，会影响到按 DECIMAL 使用的运算符和函数将在此不适用。例如，具有 PAY 数据类型的值不能与具有 INTEGER 数据类型的值相乘。因此，您必须编写只应用于 PAY 数据类型的函数。

使用单值数据类型可限制偶然错误。例如，如果将 EMPLOYEE 表的 SALARY 列定义为 PAY 数据类型，则不能将该列添加至 COMM，即使它们的源类型相同。

单值数据类型支持类型转换。源类型可以转换为单值数据类型，单值数据类型也可以转换为源类型。例如，如果将表 EMPLOYEE 的 SALARY 列定义为 PAY 数据类型，则下列示例将不会在比较运算符处出错。

     SELECT * FROM EMPLOYEE
        WHERE DECIMAL(SALARY) = 41250

DECIMAL(SALARY)返回一个十进制数据类型。相反地，数字数据类型可以转换为 PAY 类型。例如，可以使用 PAY(41250) 来转换数字 41250 的类型。

用户定义函数

如使用函数中所述，DB2 通用数据库提供内部函数和用户定义函数 (UDF)。然而，此函数集从不会满足所有需求。您常常需要为特别的任务创建定制函数。用户定义函数允许您创建定制函数。

用户定义函数有两种类型：源和外部函数。

源用户定义函数允许允许用户定义类型有选择地引用另一个已为数据库所知的内部函数或用户定义函数。您可以既使用标量函数又使用列函数。

在下一示例中，基于内部 MAX 列函数来创建称为 MAX 的用户定义函数，它采用 DECIMAL 数据类型作为输入。MAX UDF 采用 PAY 类型作为输入且返回一个 PAY 类型作为输出。

     CREATE FUNCTION MAX(PAY) RETURNS PAY
        SOURCE MAX(DECIMAL)

外部用户定义函数由用户用程序设计语言编写。有外部标量函数和外部表函数，在 SQL Reference 中讨论了这两个函数。

假定您已编写了一个计算字符串中字数的函数，则您可以使用 CREATE FUNCTION 语句以名称 WORDCOUNT 向数据库注册该函数。然后就可在 SQL 语句中使用此函数。

例如，下列语句返回雇员编号和他们简历的 ASCII 格式的字数。WORDCOUNT 是用户已向数据库注册并且现正在语句中使用的外部标量函数。

 
     SELECT EMPNO, WORDCOUNT(RESUME)
        FROM EMP_RESUME
        WHERE RESUME_FORMAT = 'ascii'

有关编写用户定义函数的更详细信息，参考 Application Development Guide。

大对象 (LOB)

术语大对象及其缩写词 LOB 用于表示三种数据类型：BLOB、CLOB 或 DBCLOB。这些类型可以包含诸如音频、图片以及文档等对象的大量数据。

二进制大对象(BLOB)是变长字符串，以字节进行量度，最大长度可达 2 吉字节。BLOB 主要用来保存非传统数据，如图片、声音以及混合媒体等。

字符大对象(CLOB)是变长字符串，以字节进行量度，最大长度可达 2 吉字节。 CLOB 用于存储大的单字节字符集数据，如文档等。CLOB 被认为是字符串。

双字节字符大对象(DBCLOB)是最大长度可达 2 吉字节的双字节字符变长字符串（1 073 741 823 双字节字符）。 DBCLOB 用于存储大的双字节字符集数据，如文档等。DBCLOB 被认为是图形字符串。

操作大对象(LOB)

由于 LOB 值可以很大，所以将它们从数据库服务器传送至客户机应用程序可能要花费一些时间。然而，一般一次处理 LOB 值的一部分，而不是将它们作为一个整体处理。对于应用程序不需要（或不想要）将整个 LOB 值存储在应用程序内存中的那些情况，应用程序可以通过大对象定位器变量引用此值。

然后后续语句可以使用定位器对数据执行操作，而不必检索整个大对象。定位器变量用来减少应用程序的存储器需求，并通过减少客户机与服务器之间的数据流而改进性能。

另一个机制是文件引用变量。它们用来直接对文件检索大对象或直接从文件来更新表中的大对象。文件引用变量用来减少应用程序的存储器需求，因为这些变量不必存储大对象数据。有关更多信息，参考 Application Development Guide 和 SQL Reference。

专用寄存器

专用寄存器是由数据库管理程序为连接定义的存储区，用于存储可以用 SQL 语句引用的信息。下列是几个较常用的专用寄存器的示例。有关所有专用寄存器的列表和更详细的信息，参考 SQL Reference。

• CURRENT DATE：保存对应于执行 SQL 语句时的日时钟的日期。

• CURRENT FUNCTION PATH：保存一个指定用于分解函数和数据类型引用的函数路径的值。

• CURRENT SERVER：指定当前应用程序服务器。

• CURRENT TIME：保存对应于执行 SQL 语句时的日时钟的时间。

• CURRENT TIMESTAMP：指定对应于执行 SQL 语句时的日时钟的时间戳记。

• CURRENT TIMEZONE：指定世界时与应用程序服务器本地时间之间的差别。

• USER：指定运行期权限 ID。

您可以用 VALUES 语句显示专用寄存器的内容。例如：

     VALUES (CURRENT TIMESTAMP)

也可以使用：

     SELECT CURRENT TIMESTAMP FROM ORG

这将为表中的每一行项返回 TIMESTAMP。

目录视图的介绍

DB2 为每个数据库创建并维护一个系统目录表扩充集。这些表包含关于数据库对象（如表、视图、程序包、参考完整性关系、函数、单值类型以及触发器等）的逻辑结构和物理结构的信息。这些表是在创建数据库时创建的，并在正常操作过程中得到更新。不能显式创建或卸下它们，但可以查询和查看其内容。

有关更多信息，参考 SQL Reference。

从系统目录中选择行

目录视图象任何其他数据库视图一样。可以使用 SQL 语句来查看数据，确切地说，就是使用查看系统中任何其他视图的相同方式。

可以在 SYSCAT.TABLES 目录中找到关于表的非常有用的信息。要寻找已创建的现存表的名称，发出一个类似以下的语句：

 
     SELECT TABNAME, TYPE, CREATE_TIME
        FROM SYSCAT.TABLES
        WHERE DEFINER = USER

此语句产生下列结果：

     TABNAME            TYPE CREATE_TIME
     ------------------ ---- --------------------------
     ORG                T    1997-05-22-11.15.27.850000
     STAFF              T    1997-05-22-11.15.29.470000
     DEPARTMENT         T    1997-05-22-11.15.30.850000
     EMPLOYEE           T    1997-05-22-11.15.31.310000
     EMP_ACT            T    1997-05-22-11.15.32.850000
     PROJECT            T    1997-05-22-11.15.34.410007
     EMP_PHOTO          T    1997-05-22-11.15.35.190000
     EMP_RESUME         T    1997-05-22-11.15.40.600000
     SALES              T    1997-05-22-11.15.43.000000

下列列表包括与本书讨论的与主题有关的目录视图。还有很多其他目录视图，它们详细地在 SQL Reference 和管理指南中列出。

说明	目录视图
检查约束	SYSCAT.CHECKS
列	SYSCAT.COLUMNS
检查约束引用的列	SYSCAT.COLCHECKS
关键字中使用的列	SYSCAT.KEYCOLUSE
数据类型	SYSCAT.DATATYPES
函数参数或函数结果	SYSCAT.FUNCPARMS
参考约束	SYSCAT.REFERENCES
模式	SYSCAT.SCHEMATA
表约束	SYSCAT.TABCONST
表	SYSCAT.TABLES
触发器	SYSCAT.TRIGGERS
用户定义函数	SYSCAT.FUNCTIONS
视图	SYSCAT.VIEWS

用约束和触发器实施商业规则

在商界，我们的确通常需要确保始终实施某些规则。例如，参与项目的雇员必须被雇用。或者想要某些事件有计划地发生。例如，如果销售员售出一批商品，则应增加其佣金。

DB2 通用数据库为此提供了一套有用的方法。 唯一约束是禁止在表的一列或多列中出现重复值的规则。 参考完整性约束确保在整个指定的表中数据一致性。 表检查约束是一些条件，它们定义为表定义的一部分，限制一列或多列中使用的值。触发器允许您定义一组操作，这些操作通过对指定的表进行删除、插入或更新操作来执行或触发。触发器可用于写入其他表、修改输入值以及发布警报信息。

第一节提供关键字的概念性概述。接着，通过示例和图表进一步探讨参考完整性、约束以及触发器。

关键字

关键字是可用来标识或存取特定行的一组列。

由不止一列组成的关键字称为组合关键字。在具有组合关键字的表中，组合关键字中各列的排序不受这些列在表中排序的约束。

唯一关键字

唯一关键字被定义为它的任何值都不相同。唯一关键字的列不能包含空值。在执行 INSERT 和 UPDATE 语句期间，数据库管理程序强制执行该约束。一个表可以有多个唯一关键字。唯一关键字是可选的，并且可在 CREATE TABLE 或 ALTER TABLE 语句中定义。

主关键字

主关键字是一种唯一关键字，表定义的一部分。一个表不能有多个主关键字，并且主关键字的列不能包含空值。主关键字是可选的，并且可在 CREATE TABLE 或 ALTER TABLE 语句中定义。

外部关键字

外部关键字在参考约束的定义中指定。一个表可以有零个或多个外部关键字。如果组合外部关键字的值的任何部分为空，则该值为空。外部关键字是可选的，并且可在 CREATE TABLE 语句或 ALTER TABLE 语句中定义。

唯一约束

唯一约束确保关键字的值在表中是唯一的。唯一约束是可选的，并且可以通过使用指定 PRIMARY KEY 或 UNIQUE 子句的 CREATE TABLE 或 ALTER TABLE 语句来定义唯一约束。例如，可在一个表的雇员编号列上定义一个唯一约束，以确保每个雇员有唯一的编号。

参考完整性约束

通过定义唯一约束和外部关键字，可以定义表与表之间的关系，从而实施某些商业规则。唯一关键和外部关键字约束的组合通常称为参考完整性约束。外部关键字所引用的唯一约束称为父关键字。外部关键字表示特定的父关键字，或与特定的父关键字相关。例如，某规则可能规定每个雇员（EMPLOYEE 表）必须属于某现存的部门（DEPARTMENT 表）。因此，将 EMPLOYEE 表中的“部门号”定义为外部关键字，而将 DEPARTMENT 表中的“部门号”定义为主关键字。下列图表提供参考完整性约束的直观说明。

图 4. 外部约束和主约束定义关系并保护数据

表检查约束

表检查约束指定对于表的每行都要进行判定的条件。可对个别列指定检查约束。可使用 CREATE 或 ALTER TABLE 语句添加检查约束。

下列语句创建具有下列约束的表：

• 部门编号的值必须在范围 10 至 100 内
• 雇员的职务只能为下列之一： "Sales"、"Mgr"或"Clerk"
• 1986 年之前雇用的每个雇员的工资必须超过 $40,500。

 
     CREATE TABLE EMP
           (ID           SMALLINT NOT NULL,
            NAME         VARCHAR(9),
            DEPT         SMALLINT CHECK (DEPT BETWEEN 10 AND 100),
            JOB          CHAR(5)   CHECK (JOB IN ('Sales', 'Mgr', 'Clerk')),
            HIREDATE     DATE,
            SALARY       DECIMAL(7,2),
            COMM         DECIMAL(7,2),
            PRIMARY KEY (ID),
            CONSTRAINT YEARSAL CHECK (YEAR(HIREDATE) >= 1986 OR SALARY > 40500) )

仅当条件判定为假时才会违反约束。例如，如果插入行的 DEPT 为空值，则插入继续进行而不出错，尽管 DEPT 的值应该象约束中定义的那样在 10 和 100 之间。

下列语句将一个约束添加至名为 COMP 的 EMPLOYEE 表中，该约束为雇员的总报酬必须超过 $15,000：

 
     ALTER TABLE EMP
        ADD CONSTRAINT COMP CHECK (SALARY + COMM > 15000)

将检查表中现存的行以确保这些行不违反新约束。可通过使用如下的 SET CONSTRAINTS 语句将此检查延期：

     SET CONSTRAINTS FOR EMP OFF
     ALTER TABLE EMP ADD CONSTRAINT COMP CHECK (SALARY + COMM > 15000)
     SET CONSTRAINTS FOR EMP IMMEDIATE CHECKED
 

首先使用 SET CONSTRAINTS 语句以延期对表的约束检查。然后可将一个或多个约束添加至表而不检查这些约束。接着再次发出 SET CONSTRAINTS 语句，反过来将约束检查打开并执行任何延期的约束检查。

触发器

一个触发器定义一组操作，这组操作通过修改指定基表中数据的操作来激活。

可使用触发器来执行对输入数据的验证；自动生成新插入行的值；为了交叉引用而读取其他表；为了审查跟踪而写入其他表；或通过电子邮件信息支持警报。使用触发器将导致应用程序开发及商业规则的全面实施更快速并且应用程序和数据的维护更容易。

DB2 通用数据库支持几种类型的触发器。可定义触发器在 DELETE、INSERT 或 UPDATE 操作之前或之后激活。每个触发器包括一组称为触发操作的 SQL 语句，这组语句可包括一个可选的搜索条件。

可进一步定义后触发器以对每一行都执行触发操作，或对语句执行一次触发操作，而前触发器总是对每一行都执行触发操作。

在 INSERT、UPDATE 或 DELETE 语句之前使用触发器，以便在执行触发操作之前检查某些条件，或在将输入值存储在表中之前更改输入值。使用后触发器，以便在必要时传播值或执行其他任务，如发送信息等，这些任务可能是触发器操作所要求的。

下列示例说明了前触发器和后触发器的使用。考虑一个记录并跟踪股票价格波动的应用程序。该数据库包含两个表，CURRENTQUOTE 和 QUOTEHISTORY，定义如下：

 
     CREATE TABLE CURRENTQUOTE
     (SYMBOL VARCHAR(10),
      QUOTE DECIMAL(5,2),
      STATUS VARCHAR(9))
     
     CREATE TABLE  QUOTEHISTORY
     (SYMBOL VARCHAR(10),
      QUOTE DECIMAL(5,2),
      TIMESTAMP TIMESTAMP)

当使用如下语句更新 CURRENTQUOTE 的 QUOTE 列时：

 
     UPDATE CURRENTQUOTE
        SET QUOTE = 68.5
        WHERE SYMBOL = 'IBM'

应更新 CURRENTQUOTE 的 STATUS 列以反映股票是否：

• 在升值
• 处于本年度的新高
• 在下跌
• 处于本年度的新低
• 价位稳定

这通过使用下列前触发器来实现：

(1)

     CREATE TRIGGER STOCK_STATUS
        NO CASCADE BEFORE UPDATE OF QUOTE ON CURRENTQUOTE
        REFERENCING NEW AS NEWQUOTE OLD AS OLDQUOTE
     FOR EACH ROW MODE DB2SQL                                   

(2)

      SET NEWQUOTE.STATUS =

(3)

         CASE

(4)

            WHEN NEWQUOTE.QUOTE >=
                      (SELECT MAX(QUOTE)
                          FROM QUOTEHISTORY         
                          WHERE SYMBOL = NEWQUOTE.SYMBOL                 
                          AND YEAR(TIMESTAMP) = YEAR(CURRENT DATE) )     
            THEN 'High'

(5)

          WHEN NEWQUOTE.QUOTE <=                             
                      (SELECT MIN(QUOTE)
                          FROM QUOTEHISTORY
                          WHERE SYMBOL = NEWQUOTE.SYMBOL                       
                          AND YEAR(TIMESTAMP) = YEAR(CURRENT DATE) )      
          THEN 'Low'

(6)

          WHEN NEWQUOTE.QUOTE > OLDQUOTE.QUOTE
             THEN 'Rising'
          WHEN NEWQUOTE.QUOTE < OLDQUOTE.QUOTE                       
             THEN 'Dropping'
          WHEN NEWQUOTE.QUOTE = OLDQUOTE.QUOTE
             THEN 'Steady'
     END                                                  
 

(1)

此代码块将名为 STOCK_STATUS 的触发器定义为一个应该在更新 CURRENTQUOTE 表的 QUOTE 列之前激活的触发器。第二行指定，在将 CURRENTQUOTE 表的实际更新所引起的任何更改应用于数据库之前，要应用触发操作。第二行也意味着触发操作将不会激活任何其他触发器。第三行指定一些名称，必须将这些名称作为列名的限定符用于新值 (NEWQUOTE) 和旧值 (OLDQUOTE)。用这些相关名（NEWQUOTE 和 OLDQUOTE）限定的列名称为转换变量。第四行表示应对每一行都执行触发操作。

(2)

这标记此触发器的触发操作中第一个也是唯一的一个 SQL 语句的开始。 SET 转换变量语句在一个触发器中用来将值赋给表的行中的列，该表正在由激活该触发器的语句进行更新。此语句正将一个值赋给 CURRENTQUOTE 表的 STATUS 列。

(3)

该赋值语句右边使用的表达式为 CASE 表达式。 CASE 表达式扩充为 END 关键字。

(4)

第一种情况检查新报价 (NEWQUOTE.QUOTE) 是否超过当前日历年度中股票符号的最高价。子查询正在使用由跟在后面的后触发器更新的 QUOTEHISTORY 表。

(5)

第二种情况检查新报价 (NEWQUOTE.QUOTE) 是否小于当前日历年度中股票符号的最低价。子查询正在使用由跟在后面的后触发器更新的 QUOTEHISTORY 表。

(6)

最后三种情况将新报价 (NEWQUOTE.QUOTE) 与表 (OLDQUOTE.QUOTE) 中的报价比较，以确定新报价是大于、小于还是等于旧报价。 SET 转换变量语句在此处结束。

除了更新 CURRENTQUOTE 表中的项之外，还需要通过将新报价连同时间戳记一起复制到 QUOTEHISTORY 表中来创建一个审查记录。这通过使用下列后触发器来实现：

(1)

     CREATE TRIGGER RECORD_HISTORY
     AFTER UPDATE OF QUOTE ON CURRENTQUOTE
     REFERENCING NEW AS NEWQUOTE
     FOR EACH ROW MODE DB2SQL
     BEGIN ATOMIC

(2)

     INSERT INTO QUOTEHISTORY
        VALUES (NEWQUOTE.SYMBOL, NEWQUOTE.QUOTE, CURRENT TIMESTAMP);
     END

(1)

此代码块将命名为 RECORD_HISTORY 的触发器定义为应该在更新 CURRENTQUOTE 表的 QUOTE 列之后激活的触发器。第三行指定应该作为列名的限定符用于新值 (NEWQUOTE) 的名称。第四行表示应对每一行都执行触发操作。

(2)

此触发器的触发操作包括单个 SQL 语句，该语句使用已更新的行中的数据（NEWQUOTE.SYMBOL 和 NEWQUOTE.QUOTE）和当前的时间戳记将该行插入 QUOTEHISTORY 表。

CURRENT TIMESTAMP 是包含时间戳记的专用寄存器。专用寄存器中提供了列表和解释。

连接

从两个或更多个表中组合数据的过程称为连接表。数据库管理程序从指定的表中形成行的所有组合。对于每个组合，它都测试连接条件。连接条件是带有一些约束的搜索条件。有关约束的列表，参考 SQL Reference。

注意：连接条件涉及的列的数据类型不必相同；然而，这些数据类型必须相容。计算连接条件的方式与计算其他搜索条件的方式相同，并且使用相同的比较规则。

如果未指定连接条件，则返回在 FROM 子句中列出的表中行的所有组合，即使这些行可能完全不相关。该结果称为这两个表的交叉积。

本节中的示例基于下面两个表。这两个表只是样本数据库中表的简化形式，在样本数据库中并不存在。这两个表一般用来概述关于连接的重点。 SAMP_STAFF 列出未作为合同工雇用的雇员的姓名以及这些雇员的职务说明，而 SAMP_PROJECT 则列出雇员（合同工和全职人员）的姓名以及这些雇员所参与的项目。

这些表如下：

图 5. SAMP_PROJECT 表

图 6. SAMP_STAFF 表

下列示例产生两个表的交叉积。因未指定连接条件，所以给出了行的所有组合：

     SELECT SAMP_PROJECT.NAME,
            SAMP_PROJECT.PROJ, SAMP_STAFF.NAME, SAMP_STAFF.JOB
        FROM SAMP_PROJECT, SAMP_STAFF

此语句产生下列结果：

     NAME       PROJ   NAME       JOB
     ---------- ------ ---------- --------
     Haas       AD3100 Haas       PRES
     Thompson   PL2100 Haas       PRES
     Walker     MA2112 Haas       PRES
     Lutz       MA2111 Haas       PRES
     Haas       AD3100 Thompson   MANAGER
     Thompson   PL2100 Thompson   MANAGER
     Walker     MA2112 Thompson   MANAGER
     Lutz       MA2111 Thompson   MANAGER
     Haas       AD3100 Lucchessi  SALESREP
     Thompson   PL2100 Lucchessi  SALESREP
     Walker     MA2112 Lucchessi  SALESREP
     Lutz       MA2111 Lucchessi  SALESREP
     Haas       AD3100 Nicholls   ANALYST
     Thompson   PL2100 Nicholls   ANALYST
     Walker     MA2112 Nicholls   ANALYST
     Lutz       MA2111 Nicholls   ANALYST

两个主要的连接类型是内连接和外连接。到目前为止，所有示例中使用的都是内连接。内连接只保留交叉积中满足连接条件的那些行。如果某行在一个表中存在，但在另一个表中不存在，则结果表中不包括该信息。

下列示例产生两个表的内连接。该内连接列出分配给某个项目的全职雇员信息：

     SELECT SAMP_PROJECT.NAME,
            SAMP_PROJECT.PROJ, SAMP_STAFF.NAME, SAMP_STAFF.JOB
        FROM SAMP_PROJECT, SAMP_STAFF
        WHERE SAMP_STAFF.NAME = SAMP_PROJECT.NAME

或者，也可以指定如下内连接：

     SELECT SAMP_PROJECT.NAME,
            SAMP_PROJECT.PROJ, SAMP_STAFF.NAME, SAMP_STAFF.JOB
        FROM SAMP_PROJECT INNER JOIN SAMP_STAFF
          ON SAMP_STAFF.NAME = SAMP_PROJECT.NAME

结果是：

     NAME       PROJ   NAME       JOB
     ---------- ------ ---------- --------
     Haas       AD3100 Haas       PRES
     Thompson   PL2100 Thompson   MANAGER

注意：该内连接的结果由右表和左表中姓名列的值匹配的行组成－ 'Haas' 和 'Thompson' 都包括在列出所有全职雇员的 SAMP_STAFF 表中以及列出分配给某个项目的专职和合同雇员的 SAMP_PROJECT 表中。

外连接是内连接和左表和／或右表中未包括内连接中的那些行的并置。当对两个表执行外连接时，可任意将一个表指定为左表而将另一个表指定为右表。外连接有三种类型：

1. 左外连接包括内连接和左表中未包括在内连接中的那些行。

2. 右外连接包括内连接和右表中未包括在内连接中的那些行。

3. 全外连接包括内连接以及左表和右表中未包括在内连接中的行。

使用 SELECT 语句来指定要显示的列。在 FROM 子句中，列出后跟关键字 LEFT OUTER JOIN、RIGHT OUTER JOIN 或 FULL OUTER JOIN 的第一个表的名称。接着需要指定后跟 ON 关键字的第二个表。在 ON 关键字后面，指定表示要连接的表之间关系的连接条件。

在下列示例中，将 SAMP_STAFF 指定为右表，而 SAMP_PROJECT 则被指定为左表。通过使用 LEFT OUTER JOIN，列出所有全职和合同雇员（在 SAMP_PROJECT 中列出）的姓名和项目编号，如果是全职雇员（在 SAMP_STAFF 中列出），还列出这些雇员的职位：

     SELECT SAMP_PROJECT.NAME, SAMP_PROJECT.PROJ,
            SAMP_STAFF.NAME, SAMP_STAFF.JOB
        FROM SAMP_PROJECT LEFT OUTER JOIN SAMP_STAFF
          ON SAMP_STAFF.NAME = SAMP_PROJECT.NAME

此语句产生下列结果：

     NAME       PROJ                 NAME       JOB
     ---------- -------------------- ---------- --------------------
     Haas       AD3100               Haas       PRES
     Lutz       MA2111               -          -
     Thompson   PL2100               Thompson   MANAGER
     Walker     MA2112               -          -

所有列中都具有值的那些行是该内连接的结果。这些都是满足连接条件的行： 'Haas' 和 'Thompson' 既在 SAMP_PROJECT（左表）中列出又在 SAMP_STAFF（右表）中列出。对于不满足连接条件的行，右表的列上出现空值： 'Lutz' 和 'Walker' 都是在 SAMP_PROJECT 表中列出的合同雇员，因而未在 SAMP_STAFF 表中列出。注意：左表中的所有行都包括在结果集中。

在下一个示例中，将 SAMP_STAFF 指定为右表而 SAMP_PROJECT 则被指定为左表。通过使用 RIGHT OUTER JOIN 列出所有专职雇员（在 SAMP_STAFF 中列出）的姓名和工作职位，如果将这些雇员分配给了某个项目（在 SAMP_PROJECT 中列出），还列出他们的项目编号：

     SELECT SAMP_PROJECT.NAME,
            SAMP_PROJECT.PROJ, SAMP_STAFF.NAME, SAMP_STAFF.JOB
        FROM SAMP_PROJECT RIGHT OUTER JOIN SAMP_STAFF
          ON SAMP_STAFF.NAME = SAMP_PROJECT.NAME

结果为：

    NAME       PROJ                 NAME       JOB
    ---------- -------------------- ---------- --------------------
    Haas       AD3100               Haas       PRES
    -          -                    Lucchessi  SALESREP
    -          -                    Nicholls   ANALYST
    Thompson   PL2100               Thompson   MANAGER

象在左外连接中一样，所有列中都具有值的那些行是内连接的结果。这些都是满足连接条件的行： 'Haas'和'Thompson'既在 SAMP_PROJECT（左表）中列出又在 SAMP_STAFF（右表）中列出。对于不满足连接条件的行，右表的列上出现空值： 'Lucchessi'和'Nicholls'都是未分配项目的专职雇员。虽然他们在 SAMP_STAFF 中列出，但未在 SAMP_PROJECT 中列出。注意：右表中的所有行都包括在结果集中。

下一个示例对 SAMP_PROJECT 表和 SAMP_STAFF 表使用 FULL OUTER JOIN。该示例列出所有专职雇员（包括未分配项目的雇员）和合同雇员的姓名：

     SELECT SAMP_PROJECT.NAME, SAMP_PROJECT.PROJ,
            SAMP_STAFF.NAME, SAMP_STAFF.JOB
        FROM SAMP_PROJECT FULL OUTER JOIN SAMP_STAFF
          ON SAMP_STAFF.NAME = SAMP_PROJECT.NAME

结果为：

     NAME       PROJ                 NAME       JOB
     ---------- -------------------- ---------- --------------------
     Haas       AD3100               Haas       PRES
     -          -                    Lucchessi  SALESREP
     -          -                    Nicholls   ANALYST
     Thompson   PL2100               Thompson   MANAGER
     Lutz       MA2111               -          -
     Walker     MA2112               -          -

此结果包括左外连接、右外连接以及内连接。列出所有专职雇员和合同雇员。正如左外连接和右外连接一样，对于不满足连接条件的值，相应列中出现空值。 SAMP_STAFF 和 SAMP_PROJECT 中的每一行都包括在结果集中。

复杂查询

DB2 通用数据库允许您通过使用 ROLLUP 和 CUBE 分组、合并及查看单个结果集中的多列。这种新型而强大的功能增强并简化了基于数据分析的 SQL。

有很多方法可从数据库中抽取有用信息。可执行递归查询从现存数据集中产生结果表。

ROLLUP 和 CUBE 查询

在查询的 GROUP BY 子句中指定 ROLLUP 和 CUBE 运算。 ROLLUP 分组产生包含常规分组行和小计行的结果集。CUBE 分组产生包含来自 ROLLUP 和交叉制表行中的行的结果集。所以对于 ROLLUP，可获取每人每月的销售量以及每月销售总量和总部总量。对于 CUBE，将包括每人销售总量的附加行。参见 SQL Reference 以了解更详细的情况。

递归查询

递归查询是迭代使用结果数据来确定进一步结果的查询。可以把这想象成在一棵树上或一幅图中来回移动。使用递归查询的常见示例包括材料单应用程序、订票系统、网络计划和调度。递归查询是使用包括引用自己名称的的公共表表达式来编写的。参见 SQL Reference 以获取递归查询的示例。

用集合运算符组合查询

UNION、EXCEPT 以及 INTERSECT 集合运算符使您能够将两个或更多外层查询组合成单个查询。执行用这些集合运算符连接的每个查询并组合各个查询的结果。根据运算符不同，产生不同的结果。

UNION 运算符

UNION 运算符通过组合其他两个结果表（例如 TABLE1 和 TABLE2）并消去表中任何重复行而派生出一个结果表。当 ALL 随 UNION 一起使用时（即 UNION ALL），不消除重复行。两种情况下，派生表的每一行不是来自 TABLE1 就是来自 TABLE2。

在下列 UNION 运算符的示例中，查询返回薪水高于 $21,000、有管理责任且工龄少于 8 年的人员的姓名：

(1)

     SELECT ID, NAME FROM STAFF WHERE SALARY > 21000
     UNION

(2)

     SELECT ID, NAME FROM STAFF WHERE JOB='Mgr' AND YEARS < 8
     ORDER BY ID
     

各个查询的结果如下：

(1)

                                                                          
     ID     NAME
     ------ ---------                                                        
        140 Fraye
        160 Molinare
        260 Jones
                                                                               

(2)

     ID     NAME
     ------ --------- 
         10 Sanders
         30 Marenghi
        100 Plotz
        140 Fraye
        160 Molinare
        240 Daniels

数据库管理程序组合这两个查询的结果，消除重复行，并按升序返回最终结果。

                                            
     ID     NAME
     ------ ---------
         10 Sanders
         30 Marenghi
        100 Plotz
        140 Fraye
        160 Molinare
        240 Daniels
        260 Jones

如果在带有任何集合运算符的查询中使用 ORDER BY 子句，则必须在最后一个查询之后写该子句。系统对组合的回答集进行排序。如果两个表中的列名不同，则组合的结果表没有相应列的名称。替代地，将这些列按其出现的顺序编号。因此，如果想要对结果表进行排序，则必须在 ORDER BY 子句中指定列号。

EXCEPT 运算符

EXCEPT 运算符通过包括所有在 TABLE1 中但不在 TABLE2 中的行并消除所有重复行而派生出一个结果表。当 ALL 随 EXCEPT 一起使用时 (EXCEPT ALL)，不消除重复行。

在下列 EXCEPT 运算符的示例中，查询返回收入超过 $21,000 但没有经理职位且工龄为 8 年或更长的所有人员的姓名。

     SELECT ID, NAME FROM STAFF WHERE SALARY > 21000
     EXCEPT
     SELECT ID, NAME FROM STAFF WHERE JOB='Mgr' AND YEARS < 8
     

各个查询的结果在关于 UNION 的一节中列出。上面的语句产生下列结果：

     ID     NAME
     ------ ---------
        260 Jones
 

INTERSECT 运算符

INTERSECT 运算符通过只包括 TABLE1 和 TABLE2 中都有的行并消除所有重复行而派生出一个结果表。当 ALL 随 INTERSECT 一起使用时 (INTERSECT ALL)，不消除重复行。

在下列 INTERSECT 运算符的示例中，查询返回收入超过 $21,000 有管理责任且工龄少于8年的雇员的姓名和 ID。

     SELECT ID, NAME FROM STAFF WHERE SALARY > 21000
     INTERSECT
     SELECT ID, NAME FROM STAFF WHERE JOB='Mgr' AND YEARS < 8

各个查询的结果在关于 UNION 的一节中列出。这两个使用 INTERSECT 的查询的结果为：

     ID     NAME
     ------ ---------
        140 Fraye
        160 Molinare
     

当使用 UNION、EXCEPT 以及 INTERSECT 运算符时，记住下列事项：

• 运算符的查询选择列表中的所有对应项必须是相容的。有关更多信息，参见 SQL Reference 中的数据类型相容性表。

• ORDER BY 子句（如果使用该子句的话）必须放在最后一个带有集合运算符的查询后面。对于每个运算符来说，如果列的名称与查询的选择列表中对应项的名称相同，则该列名只能在 ORDER BY 子句中使用。

• 在具有相同数据类型和相同长度的列之间进行的运算会产生一个具有该类型和长度的列。针对 UNION、EXCEPT 以及 INTERSECT 集合运算符的结果，参见 SQL Reference 中结果数据类型的规则。

谓词

谓词允许您构造条件，以便只处理满足这些条件的那些行。基本谓词在选择行讨论。本节讨论 IN、BETWEEN、LIKE、EXISTS 以及定量谓词。

使用 IN 谓词

使用 IN 谓词将一个值与其他几个值进行比较。例如：

     SELECT NAME
        FROM STAFF
        WHERE DEPT IN (20, 15)

此示例相当于：

     SELECT NAME
        FROM STAFF
        WHERE DEPT = 20  OR DEPT = 15

当子查询返回一组值时，可使用 IN 和 NOT IN 运算符。例如，下列查询列出负责项目 MA2100 和 OP2012 的雇员的姓：

     SELECT LASTNAME
            FROM EMPLOYEE
        WHERE EMPNO IN
           (SELECT RESPEMP
               FROM PROJECT
               WHERE PROJNO = 'MA2100'
               OR PROJNO = 'OP2012')

计算一次子查询，并将结果列表直接代入外层查询。例如，上面的子查询选择雇员编号 10 和 330，对外层查询进行计算，就好象 WHERE 子句如下：

     WHERE EMPNO IN (10, 330)

子查询返回的值列表可包含零个、一个或多个值。

使用 BETWEEN 谓词

使用 BETWEEN 谓词将一个值与某个范围内的值进行比较。范围两边的值是包括在内的，并考虑 BETWEEN 谓词中用于比较的两个表达式。

下一示例寻找收入在 $10,000 和 $20,000 之间的雇员的姓名：

     SELECT LASTNAME
            FROM EMPLOYEE
        WHERE SALARY BETWEEN 10000 AND 20000

这相当于：

     SELECT LASTNAME
            FROM EMPLOYEE
        WHERE SALARY >= 10000 AND SALARY <= 20000

下一个示例寻找收入少于 $10,000 或超过 $20,000 的雇员的姓名：

     SELECT LASTNAME
            FROM EMPLOYEE
        WHERE SALARY NOT BETWEEN 10000 AND 20000

使用 LIKE 谓词

使用 LIKE 谓词搜索具有某些模式的字符串。通过百分号和下划线指定模式。

• 下划线字符(_)表示任何单个字符。

• 百分号(%)表示零或多个字符的字符串。

• 任何其他表示本身的字符。

下列示例选择以字母'S'开头长度为 7 个字母的雇员名：

     SELECT NAME
        FROM STAFF
        WHERE NAME LIKE 'S_ _ _ _ _ _'

下一个示例选择不以字母'S'开头的雇员名：

     SELECT NAME
        FROM STAFF
        WHERE NAME  NOT LIKE 'S%'

使用 EXISTS 谓词

可使用子查询来测试满足某个条件的行的存在性。在此情况下，谓词 EXISTS 或 NOT EXISTS 将子查询链接到外层查询。

当用 EXISTS 谓词将子查询链接到外层查询时，该子查询不返回值。相反，如果子查询的回答集包含一个或更多个行，则 EXISTS 谓词为真；如果回答集不包含任何行，则 EXISTS 谓词为假。

通常将 EXISTS 谓词与相关子查询一起使用。下面示例列出当前在项目(PROJECT) 表中没有项的部门：

     SELECT DEPTNO, DEPTNAME
        FROM DEPARTMENT X
        WHERE NOT EXISTS
                 (SELECT *
                     FROM PROJECT
                     WHERE DEPTNO = X.DEPTNO)
        ORDER BY DEPTNO

可通过在外层查询的 WHERE 子句中使用 AND 和 OR 将 EXISTS 和 NOT EXISTS 谓词与其他谓词连接起来。

定量谓词

定量谓词将一个值和值的集合进行比较。如果全查询返回多个值，则必须通过附加后缀 ALL、ANY 或 SOME 来修改谓词中的比较运算符。这些后缀确定如何在外层谓词中处理返回的这组值。使用>比较运算符作为示例（下面的注释也适用于其他运算符）：

表达式 > ALL （全查询）

如果该表达式大于由全查询返回的每个单值，则该谓词为真。如果全查询未返回值，则该谓词为真。如果指定的关系至少对一个值为假，则结果为假。注意：<>ALL 定量谓词相当于 NOT IN 谓词。

下列示例使用子查询和> ALL 比较来寻找收入超过所有经理的所有雇员的姓名和职业：

     SELECT LASTNAME, JOB
            FROM EMPLOYEE
        WHERE SALARY > ALL
        (SELECT SALARY
            FROM EMPLOYEE
            WHERE JOB='MANAGER')

表达式 > ANY （全查询）

如果表达式至少大于由全查询返回的值之一，则该谓词为真。如果全查询未返回值，则该谓词为假。注意：=ANY 定量运算符相当于 IN 谓词。

表达式 > SOME（全查询）

SOME 与 ANY 同义。

标量全查询

标量全查询是在括号中的全查询，该查询返回的一行只包含一个列值。标量全查询对从数据库中检索数据值供表达式使用是很有用的。

• 下列示例列出其薪水超过全部雇员平均薪水的雇员的姓名：

   
       SELECT LASTNAME, FIRSTNME
          FROM EMPLOYEE
          WHERE  SALARY > (SELECT AVG(SALARY)
                             FROM EMPLOYEE)
  

• 下列示例在两个不同的表中查寻雇员的平均薪水：

   
       SELECT AVG(SALARY) AS "Average_Employee",
              (SELECT AVG(SALARY) AS "Average_Staff" FROM STAFF)
                  FROM EMPLOYEE
  

转换数据类型

有时可能需要将一些值从一种数据类型转换成另一种数据类型，例如，从数字值转换成字符串。要将一个值转换成另一个不同的类型，使用 CAST 说明。

转换说明的另一个可能用途是截断很长的字符串。在 EMP_RESUME 表中，RESUME 列是 CLOB(5K)。您可能只想显示包含应聘者个人信息的前 370 个字符。要从 EMP_RESUME 表中显示简历的 ASCII 格式的前 370 个字符，发出下列请求：

 
     SELECT EMPNO, CAST(RESUME AS VARCHAR(370))
        FROM EMP_RESUME
        WHERE RESUME_FORMAT = 'ascii'

会发出一个警告，通知您超过 370 个字符的值被截断。

可将空值转换为更便于在查询中进行处理的其他数据类型。 公共表表达式是一个为此目的使用转换的示例。

条件表达式

可在 SQL 语句中使用 CASE 表达式以便于处理表的数据表示。这提供了一种功能强大的条件表达式能力，在概念上与某些程序设计语言中的 CASE 语句类似。

• 要从 ORG 表中的 DEPTNAME 列将部门编号更改为有意义的词，输入下列查询：

       SELECT DEPTNAME,
          CASE DEPTNUMB
            WHEN 10 THEN 'Marketing'
            WHEN 15 THEN 'Research'
            WHEN 20 THEN 'Development'
            WHEN 38 THEN 'Accounting'
            ELSE 'Sales'
          END  AS FUNCTION
          FROM ORG
  

  结果为：

       DEPTNAME       FUNCTION
       -------------- -----------
       Head Office    Marketing
       New England    Research
       Mid Atlantic   Development
       South Atlantic Accounting
       Great Lakes    Sales
       Plains         Sales
       Pacific        Sales
       Mountain       Sales
  

• 可使用 CASE 表达式来防止出现异常情况，如被零除等。在下列示例中，如果雇员没有奖金或佣金报酬，则语句条件通过避免除法运算来防止出错：

   
       SELECT LASTNAME, WORKDEPT FROM EMPLOYEE
          WHERE(CASE
                   WHEN BONUS+COMM=0 THEN NULL
                   ELSE SALARY/(BONUS+COMM)
                END ) > 10
  

• 可在单个语句中使用 CASE 表达式，根据一个列中值的子集的总和与该列中所有值的总和的比来产生一个比率。使用 CASE 表达式的语句只需要传送数据一次。在没有 CASE 表达式的情况下，执行同样的计算至少需要传送两次。

  下列示例使用 CASE 表达式计算部门 20 的薪水之和与全部薪水总额的比率：

       SELECT CAST(CAST (SUM(CASE
                                WHEN DEPT = 20 THEN SALARY
                                ELSE 0
                             END) AS DECIMAL(7,2))/
                         SUM(SALARY) AS DECIMAL (3,2))
          FROM STAFF
  

  结果为 0.11。注意：CAST 函数确保结果的精度得到保持。

• 可使用 CASE 表达式来计算简单的函数，而不必调用函数本身，调用函数将需要额外开销。例如：

       CASE
          WHEN X<0 THEN -1
          WHEN X=0 THEN 0
          WHEN X>0 THEN 1
       END
  

  此表达式与 SYSFUN 模式中 SIGN 用户定义函数有相同的结果。

表表达式

如果只需要单个查询的视图定义，可使用表表达式。

表表达式是临时的，只在 SQL 语句的使用期限内有效；表表达式不能共享，但它们比视图更灵活。任何授权的用户都可共享视图定义。

本节描述如何在查询中使用公共表表达式和嵌套表表达式。

嵌套表表达式

嵌套表表达式是一个临时视图，其中的定义被嵌套（直接定义）在主查询的 FROM子 句中。

下列查询使用嵌套表表达式来寻找那些教育级别超过 16 的雇员的平均总收入、教育级别以及雇用年份：

 
     SELECT EDLEVEL, HIREYEAR, DECIMAL(AVG(TOTAL_PAY), 7,2)
        FROM (SELECT YEAR(HIREDATE) AS HIREYEAR, EDLEVEL,
                     SALARY+BONUS+COMM AS TOTAL_PAY
                 FROM EMPLOYEE
                 WHERE EDLEVEL > 16 )  AS PAY_LEVEL
        GROUP BY EDLEVEL, HIREYEAR
        ORDER BY EDLEVEL, HIREYEAR
 

结果如下：

     EDLEVEL HIREYEAR    3
     ------- ----------- ---------
          17        1967  28850.00
          17        1973  23547.00
          17        1977  24430.00
          17        1979  25896.50
          18        1965  57970.00
          18        1968  32827.00
          18        1973  45350.00
          18        1976  31294.00
          19        1958  51120.00
          20        1975  42110.00

此查询使用嵌套表表达式，首先从 HIREDATE 列中抽取雇用年份，以便可以在后续的 GROUP BY 子句中使用该雇用年份。您可能不想将此查询作为视图来创建，因为您打算用不同的 EDLEVEL 值来执行相似查询。

此示例中使用了标量内部函数 DECIMAL。 DECIMAL 返回数字或字符串的十进制表示。有关函数的更多详情，参考 SQL Reference。

公共表表达式

公共表表达式是在全查询的开头使用 WITH 关键字定义的命名结果表。公共表表达式是您创建以在复杂查询之中使用的表表达式。在查询的开头使用 WITH 子句定义并命名公共表表达式。对公共表表达式的重复引用使用同一个结果集。相比之下，如果使用嵌套表表达式或视图，则每次都将重新生成结果集，其结果可能各不相同。

下列示例列出公司中教育级别大于 16、平均工资比那些同时雇用的且有同样教育级别的人低的所有人。在该查询后面会更详细地描述查询的各个部分。

(1)

     WITH
           PAYLEVEL AS
              (SELECT EMPNO, YEAR(HIREDATE) AS HIREYEAR, EDLEVEL,
                      SALARY+BONUS+COMM AS TOTAL_PAY
                  FROM EMPLOYEE
                  WHERE EDLEVEL > 16),

           PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS
              (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)
                  FROM PAYLEVEL
                  GROUP BY EDLEVEL, HIREYEAR)

(3)

     SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
        FROM PAYLEVEL, PAYBYED
        WHERE EDLEVEL=EDUC_LEVEL
          AND HIREYEAR = YEAR_OF_HIRE
          AND TOTAL_PAY < AVG_TOTAL_PAY                        

(1)

这是名为 PAYLEVEL 的公共表表达式。此结果表包括雇用某个人的年份、该雇员的总收入以及他（或她）的教育级别。只包括雇员的教育级别大于 16 的那些行。

(2)

这是名为 PAYBYED（或 PAY by education）的公共表表达式。该表达式使用在前一个公共表表达式中创建的 PAYLEVEL 表来确定每个教育级别同一年雇用的雇员的教育级别、雇用年份以及平均收入。此表返回的列被赋予的名称与选择列表中所使用的列名不同（如 EDUC_LEVEL）。这会生成命名为 PAYBYED 的结果集，与嵌套表表达式示例中产生的结果相同。

(3)

最后，我们获得能产生期望结果的实际查询。连接这两个表（PAYLEVEL，PAYBYED）以确定总收入比同年雇用的人的平均收入低的那些人。注意：PAYBYED 是以 PAYLEVEL 为基础。所以在完整语句中有效地存取了 PAYLEVEL 两次。两次都使用同一组行来计算查询。

最终结果如下：

     EMPNO  EDLEVEL YEAR_OF_HIRE TOTAL_PAY     5
     ------ ------- ------------ ------------- ---------
     000210      17         1979      20132.00  25896.50

相关名

相关名是用于识别一个对象的多种用途的标识符。可在查询的 FROM 子句中和 UPDATE 或 DELETE 语句的第一个子句中定义相关名。相关名可与表、视图或嵌套表表达式关联，但只限于定义相关名的上下文中。

例如，子句 FROM STAFF S、ORG O 分别指定 S 和 O 作为 STAFF 和 ORG 的相关名。

      SELECT NAME, DEPTNAME
         FROM STAFF S, ORG O
         WHERE O.MANAGER = S.ID

一旦定义了相关名，则只可以使用相关名来限定对象。例如，上例中如果写成 ORG.MANAGER=STAFF.ID 的话，则该语句就会失效。

也可以使用相关名作为表示数据库对象的简称。只输入 S 比输入 STAFF 更容易。

通过使用相关名，可复制对象。这在需要将表中各项与自己本身作比较时很有用。在下列示例中，EMPLOYEE 表与它自己的另一个实例比较以寻找所有雇员的经理。该示例显示非设计员的雇员的姓名、这些雇员的经理的姓名以及部门编号。

     SELECT E2.FIRSTNME, E2.LASTNAME,
            E2.JOB, E1.FIRSTNME, E1.LASTNAME, E1.WORKDEPT
        FROM EMPLOYEE E1, EMPLOYEE E2
        WHERE E1.WORKDEPT = E2.WORKDEPT
          AND E1.JOB = 'MANAGER'
          AND E2.JOB <> 'MANAGER'
          AND E2.JOB <> 'DESIGNER'
 

此语句产生下列结果：

     FIRSTNME     LASTNAME        JOB      FIRSTNME     LASTNAME        WORKDEPT
     ------------ --------------- -------- ------------ --------------- --------
     DOLORES      QUINTANA        ANALYST  SALLY        KWAN            C01
     HEATHER      NICHOLLS        ANALYST  SALLY        KWAN            C01
     JAMES        JEFFERSON       CLERK    EVA          PULASKI         D21
     MARIA        PEREZ           CLERK    EVA          PULASKI         D21
     SYBIL        JOHNSON         CLERK    EVA          PULASKI         D21
     DANIEL       SMITH           CLERK    EVA          PULASKI         D21
     SALVATORE    MARINO          CLERK    EVA          PULASKI         D21
     ETHEL        SCHNEIDER       OPERATOR EILEEN       HENDERSON       E11
     MAUDE        SETRIGHT        OPERATOR EILEEN       HENDERSON       E11
     PHILIP       SMITH           OPERATOR EILEEN       HENDERSON       E11
     JOHN         PARKER          OPERATOR EILEEN       HENDERSON       E11
     RAMLAL       MEHTA           FIELDREP THEODORE     SPENSER         E21
     JASON        GOUNOT          FIELDREP THEODORE     SPENSER         E21
     WING         LEE             FIELDREP THEODORE     SPENSER         E21

相关子查询

允许引用先前提到的任何表的子查询称为相关子查询。我们也说该子查询具有对主查询中表的相关引用。

下列示例是一个不相关子查询，该子查询列出部门 'A00' 中薪水超过该部门平均薪水的雇员的雇员编号和姓名：

 
     SELECT EMPNO, LASTNAME
        FROM EMPLOYEE
        WHERE WORKDEPT = 'A00'
          AND SALARY > (SELECT AVG(SALARY)
                           FROM EMPLOYEE
                           WHERE WORKDEPT = 'A00')

如果想要知道每个部门的平均薪水，则需要对每个部门计算一次子查询。对在外层查询中标识的表的每一行，各使用一次 SQL 的相关功能（该能力允许您编写重复执行的子查询），就可做到这一点。此类型的相关子查询用来计算外层表的每一行的某个特性，该特性是在子查询中计算谓词所需要的。

此示例显示薪水高于部门平均薪水的所有雇员：

 
     SELECT E1.EMPNO, E1.LASTNAME, E1.WORKDEPT
        FROM EMPLOYEE E1
        WHERE SALARY > (SELECT AVG(SALARY)
                           FROM EMPLOYEE E2
                           WHERE E2.WORKDEPT = E1.WORKDEPT)
        ORDER BY E1.WORKDEPT

在此查询中，对每个部门计算一次子查询。结果为：

     EMPNO  LASTNAME        WORKDEPT
     ------ --------------- --------
     000010 HAAS            A00
     000110 LUCCHESSI       A00
     000030 KWAN            C01
     000060 STERN           D11
     000220 LUTZ            D11
     000200 BROWN           D11
     000170 YOSHIMURA       D11
     000150 ADAMSON         D11
     000070 PULASKI         D21
     000270 PEREZ           D21
     000240 MARINO          D21
     000090 HENDERSON       E11
     000280 SCHNEIDER       E11
     000100 SPENSER         E21
     000340 GOUNOT          E21
     000330 LEE             E21

要编写带有相关子查询的查询，使用与带有子查询的普通外部查询相同的基本格式。然而，在外部查询的 FROM 子句中，只是在表名后面放置一个相关名。于是子查询可能包含由该相关名限定的列引用。例如，如果 E1 是相关名，则 E1.WORKDEPT 表示外部查询中表的当前行的工作部门值。在外部查询中对表的每一行（概念上）重新计算子查询。

通过使用相关子查询，可以使系统为您工作并减少需要在应用程序中编写的代码量。

DB2 中允许非限定相关引用。例如，表 EMPLOYEE 有一个命名为 LASTNAME 的列，表 SALES 有一个命名为 SALES_PERSON 的列，但没有命名为 LASTNAME 的列。

 
     SELECT LASTNAME, FIRSTNME, COMM
        FROM EMPLOYEE
        WHERE 3 > (SELECT AVG(SALES)
                      FROM SALES
                      WHERE LASTNAME = SALES_PERSON)

在此示例中，系统检查最内层的 FROM 子句，以获取 LASTNAME 列。如果未找到 LASTNAME 列，则系统检查次最内层的 FROM 子句（此情况下为外部 FROM 子句）。虽然不总是必要的，还是建议限定相关引用以改进查询的可读性并确保获取想要的结果。

实现相关子查询

想何时使用相关子查询？列函数的使用有时是一条线索。

假定您想要列出教育级别高于部门平均值的雇员。

首先，您必须确定选择列表项。问题为 "List the employees"。这隐含着来自 EMPLOYEE 表中的 EMPNO 应该足以唯一标识雇员。该问题也将 EDLEVEL 和雇员的部门 WORKDEPT 说明为条件。当问题未明确要求显示列时，在选择列表中包括这些列将会有助于说明解法。现在可构造查询的一部分：

     SELECT LASTNAME, WORKDEPT, EDLEVEL
        FROM EMPLOYEE

接着需要搜索条件（WHERE子句）。问题语句为 "...whose level of education is higher than the average for that employee's department"。这意味着对于表中每个雇员，必须计算该雇员所在部门的平均教育级别。此语句适合相关子查询的说明。正在对每行计算某个特性（当前雇员所在部门的平均教育级别）。 EMPLOYEE 表需要相关名：

     SELECT LASTNAME, WORKDEPT, EDLEVEL
        FROM EMPLOYEE E1

需要的子查询较简单。该子查询计算每个部门的平均教育级别。完整的 SQL 语句为：

     SELECT LASTNAME, WORKDEPT, EDLEVEL
        FROM EMPLOYEE E1
        WHERE EDLEVEL > (SELECT AVG(EDLEVEL)
                            FROM EMPLOYEE  E2
                            WHERE E2.WORKDEPT = E1.WORKDEPT)

结果为：

     LASTNAME        WORKDEPT EDLEVEL
     --------------- -------- -------
     HAAS            A00           18
     KWAN            C01           20
     PULASKI         D21           16
     HENDERSON       E11           16
     LUCCHESSI       A00           19
     PIANKA          D11           17
     SCOUTTEN        D11           17
     JONES           D11           17
     LUTZ            D11           18
     MARINO          D21           17
     JOHNSON         D21           16
     SCHNEIDER       E11           17
     MEHTA           E21           16
     GOUNOT          E21           16

假定不列出雇员的部门编号，则应列出部门名称。需要的信息(DEPTNAME)在独立表(DEPARTMENT)中。定义相关变量的外层查询也可以是连接查询（参见从多个表中选择数据以了解详情）。

当在外层查询中使用连接时，列出要在 FROM 子句中连接的表，并将相关名放在这些表名的任何一个表名旁边。

要修改查询以列出部门名称而不是部门编号，在选择列表中用 DEPTNAME 替换 WORKDEPT。 FROM 子句现在也必须包括 DEPARTMENT 表，并且 WHERE 子句必须表示适当的连接条件。

以下是修改的查询：

     SELECT LASTNAME, DEPTNAME, EDLEVEL
        FROM EMPLOYEE E1, DEPARTMENT
        WHERE E1.WORKDEPT = DEPARTMENT.DEPTNO
        AND EDLEVEL > (SELECT AVG(EDLEVEL)
                          FROM EMPLOYEE E2
                          WHERE E2.WORKDEPT = E1.WORKDEPT)

上例显示，必须在包含相关子查询的某个查询的 FROM 子句中定义用于子查询中的相关名。然而，这种包含可能涉及若干层嵌套。

假定某些部门只有几个雇员，因此这些部门的平均教育级别可能是错误的。可以决定，为了使平均教育级别在用于比较雇员时是有意义的数字，一个部门中必须至少有 5 个雇员。因此现在必须列出教育级别高于雇员所在部门平均值的雇员，并只考虑至少有 5 个雇员的部门。

该问题暗含另一个子查询，因为对于外层查询中每个雇员来说，必须计算该雇员所在部门的雇员总数：

     SELECT COUNT(*)
        FROM EMPLOYEE E3
        WHERE E3.WORKDEPT = E1.WORKDEPT

仅当计数大于或等于 5 时才计算平均值：

     SELECT AVG(EDLEVEL)
        FROM EMPLOYEE E2
        WHERE E2.WORKDEPT = E1.WORKDEPT
        AND 5 <= (SELECT COUNT(*)
                     FROM EMPLOYEE  E3
                     WHERE E3.WORKDEPT = E1.WORKDEPT)

最后，只包括其教育级别高于部门平均值的那些雇员：

     SELECT LASTNAME, DEPTNAME, EDLEVEL
        FROM EMPLOYEE E1, DEPARTMENT
        WHERE E1.WORKDEPT = DEPARTMENT.DEPTNO
        AND EDLEVEL >
        (SELECT AVG(EDLEVEL)
            FROM EMPLOYEE E2
            WHERE E2.WORKDEPT = E1.WORKDEPT
            AND 5 <=
            (SELECT COUNT(*)
                FROM EMPLOYEE E3
                WHERE E3.WORKDEPT = E1.WORKDEPT))

此语句产生下列结果：

     LASTNAME        DEPTNAME                      EDLEVEL
     --------------- ----------------------------- -------
     PIANKA          MANUFACTURING SYSTEMS              17
     LUTZ            MANUFACTURING SYSTEMS              18
     JONES           MANUFACTURING SYSTEMS              17
     SCOUTTEN        MANUFACTURING SYSTEMS              17
     PULASKI         ADMINISTRATION SYSTEMS             16
     JOHNSON         ADMINISTRATION SYSTEMS             16
     MARINO          ADMINISTRATION SYSTEMS             17
     HENDERSON       OPERATIONS                         16
     SCHNEIDER       OPERATIONS                         17

创建表

使用 CREATE TABLE 语句创建自己的表，指定列名和类型以及约束。约束在用约束和触发器实施商业规则中讨论。

下列语句创建一个命名为 PERS 的表，该表与 STAFF 表类似，但有一个附加列 BIRTH_DATE 。

     CREATE TABLE PERS
         ( ID              SMALLINT        NOT NULL,
           NAME            VARCHAR(9),
           DEPT            SMALLINT WITH DEFAULT 10,
           JOB             CHAR(5),
           YEARS           SMALLINT,
           SALARY          DECIMAL(7,2),
           COMM            DECIMAL(7,2),
           BIRTH_DATE      DATE) 

此语句创建一个其中无数据的表。下一节描述如何将数据插入新表。

如示例中所示，为每一列都指定名称和数据类型。数据类型在数据类型中讨论。 NOT NULL 是可选的，可以指定它以表示列中不允许有空值。缺省值也是可选的。

可以在 CREATE TABLE 语句中指定许多其他选项，如唯一约束或参考约束。有关所有选项的详情，参见 SQL Reference 中的 CREATE TABLE 语句。

插入数据

当创建新表时，新表不包含任何数据。要将新的行输入表中，使用 INSERT 语句。此语句有两种一般格式：

• 一种格式，使用 VALUES 子句来指定一行或多行的列值。下面三个示例使用此一般格式将数据插入表中。

• 另一种格式，指定全查询而非指定 VALUES 来标识来自包含在其他表和／或视图中的行的列。

全查询是 INSERT 或 CREATE VIEW 语句中所使用的选择语句、或者是跟在谓词后面的选择语句。括在括号中的全查询一般称为子查询。

根据创建表时已选择的缺省选项，对于每个插入的行，为每一列提供一个值或者接受一个缺省值。各种数据类型的缺省值在 SQL Reference 中讨论。

下列语句使用 VALUES 子句将一行数据插入 PERS 表中：

  
     INSERT INTO PERS
        VALUES (12, 'Harris', 20, 'Sales', 5, 18000, 1000, '1950-1-1')
     

下列语句使用 VALUES 子句将三行插入其中只有 ID、名称以及工作是已知的 PERS 表中。如果列定义为 NOT NULL 且没有缺省值，则必须为该列指定一个值。 CREATE TABLE 语句中的列定义上的 NOT NULL 子句可以用单词 WITH DEFAULT 扩充。如果某一列定义为 NOT NULL WITH DEFAULT 或常数缺省值（如 WITH DEFAULT 10），并且您未在列列表中指定该列，则缺省值插入至已插入行的该列中。例如，在 CREATE TABLE 语句中，仅为 DEPT 列指定了缺省值并将该值定义为 10。因此，DEPT 设置为 10 而所有其他列都为空。

 
     INSERT INTO PERS (NAME, JOB, ID)
        VALUES ('Swagerman', 'Prgmr', 500),
               ('Limoges', 'Prgmr', 510),
               ('Li', 'Prgmr', 520)

下列语句返回插入的结果：

     SELECT *
        FROM PERS
 
     ID     NAME      DEPT   JOB   YEARS  SALARY    COMM      BIRTH_DATE
     ------ --------- ------ ----- ------ --------- --------- ----------
         12 Harris        20 Sales      5  18000.00   1000.00 01/01/1950
        500 Swagerman     10 Prgmr      -         -         - -
        510 Limoges       10 Prgmr      -         -         - -
        520 Li            10 Prgmr      -         -         - -

注意：在此情况下，并未给每个列指定值。空值显示为 -。为此，列名列表的次序和数据类型都必须与 VALUES 子句中提供的值对应。如果省略列名列表（如第一个示例中那样），则 VALUES 之后的数据值列表的次序必须与它们所插入至的表中的列次序相同，值的数目必须等于表中列的数目。

每个值必须与它所插入至的列的数据类型相容。如果某列定义为可空，且未指定该列的值，则将空值赋给插入行中的该列。

下列示例将空值插入 YEARS、COMM 和 BIRTH_DATE 中，因为未给行中的那些列指定值。

     INSERT INTO PERS (ID, NAME, JOB, DEPT, SALARY)
        VALUES (410, 'Perna', 'Sales', 20, 20000)

INSERT 语句的第二种格式对于用来自另一表中行的值填充表非常方便。如所述的那样，指定全查询而非指定 VALUES 以标识来自包含在其他表和／或视图中的行中的列。

下列示例从员工 STAFF 表中选择部门 38 的成员的数据，并将它插入 PERS 表中：

  
     INSERT INTO PERS (ID, NAME, DEPT, JOB, YEARS, SALARY)
        SELECT ID, NAME, DEPT, JOB, YEARS, SALARY
           FROM STAFF
           WHERE DEPT = 38

在此插入之后，下列 SELECT 语句与 INSERT 语句中全查询产生的结果相同。

     SELECT ID, NAME, DEPT, JOB, YEARS, SALARY
        FROM PERS
        WHERE DEPT = 38
 

结果为：

                                                                               
ID     NAME      DEPT   JOB   YEARS  SALARY
------ --------- ------ ----- ------ ---------
    30 Marenghi      38 Mgr        5  17506.75
    40 O'Brien       38 Sales      6  18006.00
    60 Quigley       38 Sales      -  16808.30
   120 Naughton      38 Clerk      -  12954.75
   180 Abrahams      38 Clerk      3  12009.75

更改数据

使用 UPDATE 语句来更改表中的数据。使用此语句，可以更改满足 WHERE 子句搜索条件的每行中的一列或多列的值。

下列示例更新其 ID 为 410 的雇员的信息：

     UPDATE PERS
        SET JOB='Prgmr', SALARY = SALARY + 300
        WHERE ID = 410

SET 子句指定要更新的列并提供值。

WHERE 子句是可选的，它指定要更新的行。如果省略 WHERE 子句，则数据库管理程序用您提供的值更新表或视图中的每一行。

在此示例中，首先命名表 (PERS)，然后指定要更新行的条件。雇员编号 410 的信息已更改：该雇员的工作职位更改为 Prgmr，它的薪水增加了 300$。

可以通过包括应用于两行或更多行的 WHERE 子句来更改多行数据。下列示例给每个销售员的薪水增加 15%：

     UPDATE PERS
        SET SALARY = SALARY * 1.15
        WHERE JOB = 'Sales'

删除数据

使用 DELETE 语句，基于在 WHERE 子句中指定的搜索条件从表中删除数据行。下列示例删除其中雇员 ID 为 120 的行：

 
     DELETE FROM PERS
        WHERE ID = 120

WHERE 子句是可选的，它指定要删除的行。如果省略 WHERE 子句，则数据库管理程序删除表或视图中的所有行。

可以使用 DELETE 语句删除多行。下列示例删除其中雇员部门 (DEPT) 为 20 的所有行：

     DELETE FROM PERS
        WHERE DEPT = 20

当删除某一行时，是除去整行，而不是除去行中的特定列值。

要删除表的定义及其内容，发出 DROP TABLE 语句，如 SQL Reference 中所述。

创建视图

如视图中所讨论的，视图提供在一个或多个表中查看数据的替代方法。通过创建视图，可以对想要各种用户查看的信息进行限制。下列图表显示视图和表之间的关系。

图 2. 表和视图之间的关系

在图 2中，View_A 被限制仅存取 TABLE_A 的列 AC1 和 AC2。 View_AB 允许存取 TABLE_A 中的列 AC3 和 TABLE_B 中的列 BC2。通过创建 View_A，将用户可以具有的存取权限制于 TABLE_A，通过创建 VIEW_AB，将存取权限制于某些列并创建查看数据的替代方式。

下列语句创建 STAFF 表 中 20 部门的非经理人员视图，其中薪水和佣金不通过基表显示。

  
     CREATE VIEW STAFF_ONLY
        AS SELECT ID, NAME, DEPT, JOB, YEARS
              FROM STAFF
              WHERE JOB <> 'Mgr' AND DEPT=20

在创建视图之后，下列语句显示视图的内容：

     SELECT *
        FROM STAFF_ONLY

此语句产生下列结果：

      
ID     NAME      DEPT   JOB   YEARS
------ --------- ------ ----- ------
    20 Pernal        20 Sales      8
    80 James         20 Clerk      -
   190 Sneider       20 Clerk      8

早些时候，我们把 STAFF 和 ORG 表连接起来产生一个列出每个部门名称及其部门经理姓名的结果。下列语句创建可重复用于相同目的的视图：

  
     CREATE VIEW DEPARTMENT_MGRS
        AS SELECT NAME, DEPTNAME
              FROM STAFF, ORG
              WHERE MANAGER = ID

创建视图时，可以使用 WITH CHECK OPTION 子句将附加约束添加到通过视图插入和更新表。此子句导致数据库管理程序验证对视图的任何更新或插入是否符合该视图的定义，并拒绝那些不符合定义的更新或插入。如果省略此子句，则不检查违反视图定义的插入和更新。有关 WITH CHECK OPTION 如何起作用的详情，参考 SQL Reference 中的 CREATE VIEW 语句。

使用视图来处理数据

象 SELECT 语句一样，INSERT、DELETE 以及 UPDATE 语句可以应用于视图，就好象视图是一个实表一样。这些语句处理基本基表中的数据。因此当再次存取该视图时，使用最新的基表对它进行计算。如果未使用 WITH CHECK OPTION，则使用视图修改的数据可能由于不再满足原始视图定义而不在视图的重复存取中出现。

下列是一个将更新应用于视图 FIXED_INCOME 的示例：

FIXED_INCOME 的视图定义：

     CREATE VIEW FIXED_INCOME (LNAME, DEPART, JOBTITLE, NEWSALARY)
        AS SELECT NAME, DEPT, JOB, SALARY
              FROM PERS
              WHERE JOB <> 'Sales' WITH CHECK OPTION

     UPDATE FIXED_INCOME
        SET NEWSALARY = 19000
        WHERE LNAME = 'Li'

除了校验选项以外，先前视图中的更新等效于对基表 PERS 的更新：

     UPDATE PERS
        SET SALARY = SALARY * 1.10
        WHERE NAME = 'Li'
          AND JOB <> 'Sales'

注意：由于视图是在 CREATE VIEW FIXED_INCOME 中对约束 JOB <> 'Sales'使用 WITH CHECK OPTION 创建的，所以当 Limoges 调去做销售时不允许下列更新：

     UPDATE FIXED_INCOME
        SET JOBTITLE = 'Sales'
        WHERE LNAME = 'Limoges'

不能更新由表达式 SALARY + COMM or SALARY * 1.25 定义的列。如果定义的视图包含一列或多个这样的列，则拥有者不接受对这些列的更新(UPDATE)特权。在包含这样的列的视图上不允许 INSERT 语句，但允许 DELETE 语句。

考虑一个没有一列定义为 NOT NULL 的 PERS 表。可以通过 FIXED_INCOME 视图将行插入 PERS 表中，即使该视图不包含基本表 PERS 的 ID、YEARS、COMM 或 BIRTHDATE。整个视图中看不到的列被适当地设置为空值或缺省值。

然而，PERS 表确实已将列 ID 定义为 NOT NULL。如果尝试通过 FIXED_INCOME 视图插入行，则系统试图将空值插入在整个视图中“看不到”的所有 PERS 列。由于 ID 列未包括在视图中并且该列不允许空值，所以系统不允许通过该视图进行插入。

表是由定义的列数和可变的行数组成的逻辑结构。列是一组相同数据类型的值。在表中不必对行进行排序。要对结果集进行排序，必须在从表中选择数据的 SQL 语句中显式指定排序。在每个列和行的相交处是一个称为值的特定数据项。在图 1中，'Sanders' 是表中值的一个示例。

基表是用 CREATE TABLE 语句创建的，用于保存用户数据。结果表是一组行，数据库管理程序从一个或多个基表选择或生成这组行以满足查询要求。

图 1说明了表的一部分。列和行已标记。

图 1. 表的可视化

视图

视图提供了在一个或多个表中查看数据的替代方法。它是表上的一个动态窗口。

视图允许多个用户查看同一数据的不同表示。例如，几个用户可以同时存取一个关于雇员的数据表。一个用户可以查看关于某些雇员而非其他雇员的数据，而另一个用户可以查看关于所有雇员的某些数据而非他们的薪水。这些用户的每一个都在操作一个从该实表派生的视图。每个视图都显示为一个表并有自己的名称。

使用视图的优点是您可以使用它们来控制对敏感数据的存取。所以，不同的人可以存取数据的不同列或行。

模式

模式是命名对象的集合，并提供了数据库中对象的逻辑分类。模式可以包含数据库对象，如表和视图等。

模式本身也可以认为是数据库中的一个对象。当创建表或视图时隐式创建了模式。或者，可以使用 CREATE SCHEMA 语句显式创建它。

创建对象时，可以用特定模式的名称来限定对象的名称。命名对象有两部分名称，其中第一部分名称是指定给对象的模式名。如果未指定模式名，则给对象指定其名称是用户执行语句的权限 ID 的缺省模式。对于交互式 SQL，该方法用于执行本书中的示例，权限 ID 为用 CONNECT 语句指定的用户 ID。例如，如果表名为 STAFF，CONNECT 语句中指定的用户 ID 为 USERID，则限定名为 USERID.STAFF。参见连接数据库以获取关于 CONNECT 语句的详情。

某些模式名是系统保留的。例如，当预安装的用户定义函数 属于 SYSFUN 模式时，内部函数处于 SYSIBM 模式。参考 SQL Reference 以获取关于 CREATE SCHEMA 语句的详情。

数据类型

数据类型定义常数、列、宿主变量、函数、表达式以及专用寄存器可接受的值。本节描述示例中引用的数据类型。有关其他数据类型的完整列表和说明，参考 SQL Reference。

字符串

字符串为一个字节序列。字符串的长度为序列中的字节数。如果长度为零，则该字符串的值称为空字符串。
定长字符串

CHAR(x)是定长字符串。长度属性 x 必须在 1 和 254 之间，并包括 1 和 254。

变长字符串

变长字符串有三种类型：VARCHAR、LONG VARCHAR 以及 CLOB。 VARCHAR(x)类型是变长字符串，因此，可以将长度为 9 的字符串插入 VARCHAR(15)中，而该字符串的长度将仍然为 9。参见大对象 (LOB)以获取关于 CLOB 的详情。

图形字符串

图形字符串是一个双字节字符数据序列。

定长图形字符串

GRAPHIC(x)是定长字符串。长度属性 x 必须在 1 和 127 之间，并包括 1 和 127。

变长图形字符串

变长图形字符串有三种类型：VARGRAPHIC、LONG VARGRAPHIC 以及 DBCLOB。参见大对象 (LOB)以获取关于 DBCLOB 的详情。

二进制字符串

二进制字符串是一个字节序列。它用于保存非传统数据，如图象等。“二进制大对象”(BLOB)是二进制字符串。参见大对象 (LOB)以了解更多信息。

数字

所有数字都有符号和精度。精度是除符号位以外的位数或数字数。

SMALLINT

SMALLINT（小型整数）是精度为 5 位的两字节整数。

INTEGER

INTEGER（大型整数）是精度为 10 位的四字节整数。

REAL

REAL（单精度浮点数）是实数的 32 位近似值。

DOUBLE

DOUBLE（双精度浮点数）是实数的 64 位近似值。 DOUBLE 也称 FLOAT。

DECIMAL(p,s)

DECIMAL 是一个十进制数。小数点的位置由数字的 精度(p)和小数位(s) 确定。精度是数字的总位数，必须小于 32。小数位是小数部分数字的位数且总是小于或等于精度值。如果未指定精度和小数位，则十进制值的缺省精度为 5，缺省小数位为 0。

日期时间值

日期时间值是日期、时间以及时间戳记的表示。日期时间值可以用于某些算术运算和字符串运算并且与某些字符串是相容的，然而它们既非字符串也非数字。 (1)

日期

日期值分为三个部分（年、月以及日）。

时间

时间是用 24 小时制式来指定一天内的时间的值，分为三个部分（小时、分钟以及秒）。

时间戳记

时间戳记为指定日期和时间的值，分为七个部分（年、月、日、小时、分钟、秒以及微秒）。

空值是一个区别于所有非空值的特殊值。它意味着行中的那一列无任何其他值。所有数据类型都存在空值。

下表突出显示示例中所使用的数据类型的特性。所有数字数据类型都定义在某一确定范围内。该数字数据类型范围也包括在此表中。可以使用此表作为正确数据类型用法的快速参考。

数据类型	类型	特性	示例或范围
CHAR(15)	定长字符串	最大长度为 254	'Sunny day      '
VARCHAR(15)	变长字符	最大长度为 4000	'Sunny day'
SMALLINT	数字	长度为 2 字节 精度为 5 位	范围为-32768 至 32767
INTEGER	数字	长度为 4 字节 精度为 10 位	范围为-2147483648 至 2147483647
REAL	数字	单精度 浮点 32 位近似值	范围为 -3.402E+38 至-1.175E-37 或 1.175E-37 至-3.402E+38 或零
DOUBLE	数字	双精度 浮点 64 位近似值	范围为 -1.79769E+308 至-2.225E-307 或 2.225E-307 至 1.79769E+308 或零
DECIMAL(5,2)	数字	精度为 5 小数位为 2	范围为 -10**31+1 至 10**31-1
DATE	日期时间	三部分值	1991-10-27
TIME	日期时间	三部分值	13.30.05
TIMESTAMP	日期时间	七部分值	1991-10-27-13.30.05.000000

final关键字最基本的含义就是表明“这个东西不能改变”。之所以这样，可能是考虑到两方面的因素：设计或效率。

final关键字可应用在三种场合： 数据、方法以及类

1. final数据

表明某个数据是“常数”，永远不会改变。使用final定义，编译器可以直接将常数值封装到需要的计算过程里。也就是说，计算可以在编译期前执行，从而节省运行时的开销。在JAVA中，这些常数必须属于基本数据类型。并且在对这样的一个常数进行定义的时候，必须给出一个值。

而当对象句柄使用final时，必须将句柄初始化到一个具体的对象，而且永远不能将句柄指向另一个对象。然而，对象本身可以修改。

空白final

Java允许创建“空白final”。即不赋初始值，但空白final必须在实际使用前得到正确的初始化。如果将赋初始值的语句放在不同的构造器中，则final字段可以随着调用不同的构造器而获得不同的初始值。但一旦确定，值将无法改变。

final数据无法更改：

{
  final int i=5;
  i=6;
}

以上语句会在编译期间出错：
:cannot assign a value to final variable i=6;

final自变量

JAVA允许将自变量设成final属性。即在方法的变量列表中进行声明。这样意味着在一个方法内部，不能改变自变量句柄所指向的东西。

2. final 方法

将一个方法标识为final，则可防止任何继承类改变这个方法的本来含义。即不可被覆盖或改写。

同时将一个方法设置成final后，编译器可以把对那个方法的所有调用都嵌入到调用里，即采用常规的代码插入方法。因此可以提高程序效率。当然，如果方法体积太大，那么程序就会变的臃肿。

因此，通常只有在方法的代码量非常少，或者想明确禁止方法被覆盖的时候，才应考虑将一个方法设置为final 。

类中所有的private方法都自动成为final。因为我们不能从类外访问final方法，所以它绝对不会被其他方法覆盖。

3. final类

若在整个类定义前冠以final关键字，表明不希望从这个类继承。而final类的数据成员既可以是final的，也可以不是。因为final类禁止了继承，所以final类中的所有方法都默认为final。因为此时不可能覆盖它们。（当然可以再为final类中的方法添加final指示符号，但这样做没有任何意义）

ActionMapping类
将特定请求映射到特定Action的相关信息存储在ActionMapping中，ActionServelt将ActionMapping传送到Action类的execute()方法，Action将使用ActionMapping的findForward()方法，此方法返回一个指定名称的ActionForward，这样Action就完成了本地转发。若没有找到具体的ActionForward，就返回一个null.
ActionMapping的方法:
public ExceptionConfig findException(Class type) ,查找异常对象
public ActionForward findForward(String name) 可在映射中动态添加ActionForward:
public String[] findForwards()找到一个Action可以使用的actionForward列表
public ActionForward getInputForward() 得到本action的输入ActionForard.
ActionMapping继承于org.apache.struts.config.ActionConfig
Action类
Action类真正实现应用程序的事务逻辑，它们负责处理请求。在收到请求后，ActionServlet会：
1.为这个请求选择适当的Action
2.如果需要，创建Action的一个实例
3.调用Action的execute()方法
如果ActionServlet不能找到有效的映射，它会调用默认的Action类(在配置文件中定义)。如果找到了ActionServlet将适当的ActionMapping类转发给Action，这个Action使用ActionMapping找到本地转发，然后获得并设置ActionMapping属性。根据servlet的环境和被覆盖的execute ()方法的签名，ActionServlet也会传送ServletRequest对象或HttpServletRequest对象。
所有Action类都扩展org.apache.struts.action.Action类，并且覆盖类中定义的某一个execute ()方法。有两个execute ()方法：
处理非HTTP（一般的）请求：
public ActionForward execute (ActionMapping action,
Acionform form,
ServletRequest request,
ServletResponse response)
throws java.lang.Exception
处理HTTP请求：
public ActionForward execute (ActionMapping action,
Acionform form,
HttpServletRequest request,
HttpServletResponse response)
throws java.lang.Exception
Action类必须以”线程安全”的方式进行编程，因为控制器会令多个同时发生的请求共享同一个实例，相应的，在设计Action类时就需要注意以下几点：
不能使用实例或静态变量存储特定请求的状态信息，它们会在同一个操作中 共享跨越请求的全局资源
如果要访问的资源（如JavaBeans和会话变量）在并行访问时需要进行保护，那么访问就要进行同步
Action类的方法
除了execute ()方法外，还有以下方法：
可以获得或设置与请求相关联的区域：
public Locale getLocale(HttpServletRequest request)
public void setLocale(HttpServletRequest request,Locale locale)
为应用程序获得消息资源：
protected MessageResources getResources(HttpServletRequest request)
protected MessageResources getResources(HttpServletRequest request,String key)
检查用户是否点击表单上的”取消”键，如果是，将返回true:
public Boolean isCancelled(HttpServletRequest request)
当应用程序发生错误时，Action类能够使用下面方法存储错误信息：
public void saveErrors(HttpServletRequest request,ActionErrors errors)
public void saveMessages(HttpServletRequest request,ActionMessages messages)
ActionError实例被用来存储错误信息，这个方法在错误关键字下的请求属性列表中存储ActionError对象。通过使用在struts标记库中定义的自定义标记，JSP页能够显示这些错误信息。ActionMessages 用来存储一些提示信息，不是错误，在jsp页面可以使用标记现实这些提示信息。
请求有效性处理,使用令牌可以有效的防止重复提交。
protected String generateToken(HttpServletRequest request) 创建一个令牌.
protected boolean isTokenValid(HttpServletRequest request) 检查令牌是否有效
protected boolean isTokenValid(HttpServletRequest request,Boolean reset) 检查令牌是否有效，并且重置令牌（如果reset 是true）
protected void resetToken(HttpServletRequest request) 重置令牌
protected void saveToken(HttpServletRequest request) 添加令牌
获取数据库连接
protected DataSource getDataSource(HttpServletRequest request)
protected DataSource getDataSource(HttpServletRequest request, String key)
其他的
ActionServlet getServlet() 可以获得本action的配置信息.

DispatchAction类
DispatchAction是Action的子类，主要功能可以实现，动态的方法调用。例如action中有一个方法update（ActionMapping mapping, Actionform form, HttpServletRequest request, HttpServletResponse response）, 可以通过 saveSubs cription.do?method=update来调用update方法。这个类不需要我们实现其他方法，我们只要实现 XXX（ActionMapping mapping, Actionform form, HttpServletRequest request, HttpServletResponse response）就可以了。
在http://www.chinajavaworld.net/forum/topic.cgi?forum=48&topic=1166&show=150和
http://www.chinajavaworld.net/forum/topic.cgi?forum=48&topic=1129有对DispatchAction和LookupDispatchAction的详细介绍


SwitchAction类
SwitchAction是Action的子类，主要功能是将请求在不同的模块之间转发。对于大的项目很有用。具体看http://www.chinajavaworld.net/forum/topic.cgi?forum=48&topic=1029&show=0

Actionform类
假设用户在应用程序中为每个表单都创建了一个Actionform bean，对于每个在struts-config.xml文件中定义的bean，框架在调用Action类的execute()方法之前会进行以下操作：
在相关联的关键字下，它检查用于适当类的bean实例的用户会话(或请求)，如果在会话(或请求)中没有可用的bean，它就会自动创建一个新的bean并添加到用户的会话(或请求)中。至于是在会话还是请求取决于struts-config.xml 中Action 的scope属性。在创建Actionform的时候，系统会将请求中的值，进行相应的类型转换以后对Actionform进行初始化。
对于请求中每个与bean属性名称对应的参数，Action调用相应的设置方法。
当Action execute()被调用时，最新的Actionform bean传送给它，参数值就可以立即使用了。
Actionform类扩展org.apache.struts.action.Actionform类，程序开发人员创建的bean能够包含额外的属性，而且ActionServlet可能使用反射（允许从已加载的对象中回收信息）访问它。
Actionform类提供了另一种处理错误的手段，提供两个方法：
Public ActionErrors validate(ActionMappin mapping, ServletRequest request)
Public ActionErrors validate(ActionMappin mapping, HttpServletRequest request)
你应该在自己的bean里覆盖validate()方法，并在配置文件里设置<action>元素的validate为true。在ActionServlet调用Action类前，它会调用validate()，如果返回的ActionErrors不是null，则Actinform会根据错误关键字将ActionErrors存储在请求属性列表中。
如果返回的不是null，而且长度大于0，则根据错误关键字将实例存储在请求的属性列表中，然后ActionServlet将响应转发到配置文件<action>元素的input属性所指向的目标。
如果需要执行特定的数据有效性检查，最好在Action类中进行这个操作，而不是在Actionform类中进行。
方法reset()可将bean的属性恢复到默认值：
public void reset(ActionMapping mapping,HttpServletRequest request)
public void reset(ActionMapping mapping,ServletRequest request)
典型的ActionFrom bean只有属性的设置与读取方法（getXXX）,而没有实现事务逻辑的方法。只有简单的输入检查逻辑，使用的目的是为了存储用户在相关表单中输入的最新数据，以便可以将同一网页进行再生，同时提供一组错误信息，这样就可以让用户修改不正确的输入数据。而真正对数据有效性进行检查的是Action类或适当的事务逻辑bean。
Actionform中属性允许的类型boolean,byte,short,char,int,long,float,double,Boolean,Btye,Short, Character,Integer,Long,Float,Double,String,Date,Time,Timestamp，Object，以及以上类型的数组。
如果Actionform bean 的属性是一个数组则相应的设置和读取方法要做部分修改。对于数组setXXX(…),和getXXX()在jsp页面中意义不大。应该将添加setXXX( int index , …. ) 方法和getXXX ( int index )方法。这两个方法对于jsp页面来说更有意义。jsp中的property应该是XXX[0]。
如果Actionform bean的属性是一个 Map则应该提供方法setXXX( String key , … )和getXXX(String key)，使得jsp页面可以访问Map属性。jsp中的properry应该是XXX(keyname)。
通过getXXX(int index),setXXX (int index,…),getXXX(String key),setXXX(String key,…)可以方便的实现重复html输入框。
例如：
public class Fooform extends Actionform {
private String yourName;
public String getYourName() {
return yourName;
}
public void setYourName(String yourName) {
this.yourName = yourName;
}
private final Map values = new HashMap();
public void setvalue(String key, Object value) {
values.put(key, value);
}
public Object getvalue(String key) {
if ( values.containsKey(key)){
return values.get(key);
}else{
return "";
}
}
…
}


Validatorform类
org.apache.struts.validator.Validatorform类继承了Actionform类。使用本类可以方便的实现表单参数的校验。在校验的时候，使用在struts-config.xml中action元素中的name属性,确定要在validation.xml中取得校验规则的依据。
使用本类可以方便的解决同一个form在不同的Action中使用不同的校验规则的问题。在继承了Validatorform的类中不再需要我们去写validate方法。而是由Validatorform中的validate方法通过读取validation.xml中的描述信息来进行数据的校验。使用Validatorform也可以方便的实现在浏览器端实现利用脚本的校验。
Validatorform中的新增加的方法：
int getPage()
java.util.Map getResultvalueMap()
ValidatorResults getValidatorResults()
void setPage(int page)
void setValidatorResults()
使用本类可以大大提高我们的编程效率。
ValidatorActionform类
org.apache.struts.validator.ValidatorActionform类继承了Validatorform类。使用本类可以方便的实现表单参数的校验。在校验的时候，使用在struts-config.xml中action元素中的path属性,确定要在validation.xml中取得校验规则的依据。

DynaActionform类
org.apache.struts.action.DynaActionform类继承了Actionform类。使用本类可以方便的实现动态表单。创建不确定的表单，如果jsp发生了变化只需要修改jsp页面和struts-config.xml文件中的form-bean元素就可以了。我们的程序中完全可以不用手工书写actionform的类了。
DynaActionform中的方法：
boolean contains(String name, String key) 检测name（key）在actionform中是否存在。
Object get(String name) 从actionform中取得name的值。
Object get(String name,int index) 从actionform中取得 name对象的index个值。
Object get(String name,String key)从actionform中取得name对象的key对应的值。
Map getMap() 返回对象中包含的对象属性名列表。
void remove(String name, String key) 删除一个元素。
void set(String name, int index,Object value) 对actionform中的属性进行赋值。
void set(String name,Object value)
void set(String name, Strign key ,Object value)

DynaValidatorform类
org.apache.struts.validator.DynaValidatorform类继承了DynaActionform类。使用本类可以方便的实现表单参数的校验。在校验的时候，使用在struts-config.xml中action元素中的name属性,确定要在validation.xml中取得校验规则的依据。
至于校验，同Validatorform。
DynaValidatorform中的新增加的方法：
int getPage()
java.util.Map getResultvalueMap()
ValidatorResults getValidatorResults()
void setPage(int page)
void setValidatorResults()

DynaValidatorActionform类
org.apache.struts.validator.DynaValidatorActionform类继承了DynaValidatorform类。使用本类可以方便的实现表单参数的校验。在校验的时候，使用在struts-config.xml中action元素中的path属性,确定要在validation.xml中取得校验规则的依据。
至于校验，同Validatorform。

ActionForward类
ActionForward类继承了org.apache.struts.config.ForwardConfig。
ForwardConfig的方法:
String getName() 虚名字
String getPath() 实际路径
boolean getRedirect() 是否重定向
void setName(String name)
void setPath(String path)
void setRedirect(boolean redirect)

ActionForward目的是控制器将Action类的处理结果转发至目的地。
Action类获得ActionForward实例的句柄，然后可用两种方法返回到ActionServlet，
ActionMapping实例被传送到execute()方法，使用actionMapping的findForward(String name)根据名称获取一个全局转发或本地转发。
另一种是调用下面的一个构造器来创建它们自己的一个实例：
public ActionForward()
public ActionForward(String path)
public ActionForward(String path,Boolean redirect)
public ActionForward(String name,String path,Boolean redirect)
public ActionForward(String name,String path,Boolean redirect, boolean contextRelative)
或下面的构造方法(下面是ActionForward的子类)
ForwardingActionForward()
ForwardingActionForward(String path)
RedirectingActionForward()
RedirectingActionForward(String path)

一． Input和Output
1. stream代表的是任何有能力产出数据的数据源，或是任何有能力接收数据的接收源。在Java的IO中，所有的stream（包括Input和Out stream）都包括两种类型：
1.1 以字节为导向的stream
以字节为导向的stream，表示以字节为单位从stream中读取或往stream中写入信息。以字节为导向的stream包括下面几种类型：
1) input　stream：
1) ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使用
2) StringBufferInputStream：把一个String对象作为InputStream
3) FileInputStream：把一个文件作为InputStream，实现对文件的读取操作
4) PipedInputStream：实现了pipe的概念，主要在线程中使用
5) SequenceInputStream：把多个InputStream合并为一个InputStream
2) Out　stream
1) ByteArrayOutputStream：把信息存入内存中的一个缓冲区中
2) FileOutputStream：把信息存入文件中
3) PipedOutputStream：实现了pipe的概念，主要在线程中使用
4) SequenceOutputStream：把多个OutStream合并为一个OutStream
1.2 以Unicode字符为导向的stream
以Unicode字符为导向的stream，表示以Unicode字符为单位从stream中读取或往stream中写入信息。以Unicode字符为导向的stream包括下面几种类型：
1) Input　Stream
1) CharArrayReader：与ByteArrayInputStream对应
2) StringReader：与StringBufferInputStream对应
3) FileReader：与FileInputStream对应
4) PipedReader：与PipedInputStream对应
2) Out　Stream
1) CharArrayWrite：与ByteArrayOutputStream对应
2) StringWrite：无与之对应的以字节为导向的stream
3) FileWrite：与FileOutputStream对应
4) PipedWrite：与PipedOutputStream对应
以字符为导向的stream基本上对有与之相对应的以字节为导向的stream。两个对应类实现的功能相同，字是在操作时的导向不同。如CharArrayReader：和ByteArrayInputStream的作用都是把内存中的一个缓冲区作为InputStream使用，所不同的是前者每次从内存中读取一个字节的信息，而后者每次从内存中读取一个字符。
1.3 两种不现导向的stream之间的转换
InputStreamReader和OutputStreamReader：把一个以字节为导向的stream转换成一个以字符为导向的stream。
2. stream添加属性
2.1 “为stream添加属性”的作用
运用上面介绍的Java中操作IO的API，我们就可完成我们想完成的任何操作了。但通过FilterInputStream和FilterOutStream的子类，我们可以为stream添加属性。下面以一个例子来说明这种功能的作用。
如果我们要往一个文件中写入数据，我们可以这样操作：
FileOutStream fs = new FileOutStream(“test.txt”);
然后就可以通过产生的fs对象调用write()函数来往test.txt文件中写入数据了。但是，如果我们想实现“先把要写入文件的数据先缓存到内存中，再把缓存中的数据写入文件中”的功能时，上面的API就没有一个能满足我们的需求了。但是通过FilterInputStream和FilterOutStream的子类，为FileOutStream添加我们所需要的功能。
2.2 FilterInputStream的各种类型
2.2.1 用于封装以字节为导向的InputStream
1) DataInputStream：从stream中读取基本类型（int、char等）数据。
2) BufferedInputStream：使用缓冲区
3) LineNumberInputStream：会记录input stream内的行数，然后可以调用getLineNumber()和setLineNumber(int)
4) PushbackInputStream：很少用到，一般用于编译器开发
2.2.2 用于封装以字符为导向的InputStream
1) 没有与DataInputStream对应的类。除非在要使用readLine()时改用BufferedReader，否则使用DataInputStream
2) BufferedReader：与BufferedInputStream对应
3) LineNumberReader：与LineNumberInputStream对应
4) PushBackReader：与PushbackInputStream对应
2.3 FilterOutStream的各种类型
2.2.3 用于封装以字节为导向的OutputStream
1) DataIOutStream：往stream中输出基本类型（int、char等）数据。
2) BufferedOutStream：使用缓冲区
3) PrintStream：产生格式化输出
2.2.4 用于封装以字符为导向的OutputStream
1) BufferedWrite：与对应
2) PrintWrite：与对应
3. RandomAccessFile
1) 可通过RandomAccessFile对象完成对文件的读写操作
2) 在产生一个对象时，可指明要打开的文件的性质：r，只读；w，只写；rw可读写
3) 可以直接跳到文件中指定的位置
4. I/O应用的一个例子
import java.io.*;
public class TestIO{
public static void main(String[] args)
throws IOException{
//1.以行为单位从一个文件读取数据
BufferedReader in =
new BufferedReader(
new FileReader("F:\\nepalon\\TestIO.java"));
String s, s2 = new String();
while((s = in.readLine()) != null)
s2 += s + "\n";
in.close();

//1b. 接收键盘的输入
BufferedReader stdin =
new BufferedReader(
new InputStreamReader(System.in));
System.out.println("Enter a line:");
System.out.println(stdin.readLine());

//2. 从一个String对象中读取数据
StringReader in2 = new StringReader(s2);
int c;
while((c = in2.read()) != -1)
System.out.println((char)c);
in2.close();

//3. 从内存取出格式化输入
try{
DataInputStream in3 =
new DataInputStream(
new ByteArrayInputStream(s2.getBytes()));
while(true)
System.out.println((char)in3.readByte());
}
catch(EOFException e){
System.out.println("End of stream");
}

//4. 输出到文件
try{
BufferedReader in4 =
new BufferedReader(
new StringReader(s2));
PrintWriter out1 =
new PrintWriter(
new BufferedWriter(
new FileWriter("F:\\nepalon\\ TestIO.out")));
int lineCount = 1;
while((s = in4.readLine()) != null)
out1.println(lineCount++ + "：" + s);
out1.close();
in4.close();
}
catch(EOFException ex){
System.out.println("End of stream");
}

//5. 数据的存储和恢复
try{
DataOutputStream out2 =
new DataOutputStream(
new BufferedOutputStream(
new FileOutputStream("F:\\nepalon\\ Data.txt")));
out2.writeDouble(3.1415926);
out2.writeChars("\nThas was pi:writeChars\n");
out2.writeBytes("Thas was pi:writeByte\n");
out2.close();
DataInputStream in5 =
new DataInputStream(
new BufferedInputStream(
new FileInputStream("F:\\nepalon\\ Data.txt")));
BufferedReader in5br =
new BufferedReader(
new InputStreamReader(in5));
System.out.println(in5.readDouble());
System.out.println(in5br.readLine());
System.out.println(in5br.readLine());
}
catch(EOFException e){
System.out.println("End of stream");
}

//6. 通过RandomAccessFile操作文件
RandomAccessFile rf =
new RandomAccessFile("F:\\nepalon\\ rtest.dat", "rw");
for(int i=0; i<10; i++)
rf.writeDouble(i*1.414);
rf.close();

rf = new RandomAccessFile("F:\\nepalon\\ rtest.dat", "r");
for(int i=0; i<10; i++)
System.out.println("Value " + i + "：" + rf.readDouble());
rf.close();

rf = new RandomAccessFile("F:\\nepalon\\ rtest.dat", "rw");
rf.seek(5*8);
rf.writeDouble(47.0001);
rf.close();

rf = new RandomAccessFile("F:\\nepalon\\ rtest.dat", "r");
for(int i=0; i<10; i++)
System.out.println("Value " + i + "：" + rf.readDouble());
rf.close();
}
}
关于代码的解释（以区为单位）：
1区中，当读取文件时，先把文件内容读到缓存中，当调用in.readLine()时，再从缓存中以字符的方式读取数据（以下简称“缓存字节读取方式”）。
1b区中，由于想以缓存字节读取方式从标准IO（键盘）中读取数据，所以要先把标准IO（System.in）转换成字符导向的stream，再进行BufferedReader封装。
2区中，要以字符的形式从一个String对象中读取数据，所以要产生一个StringReader类型的stream。
4区中，对String对象s2读取数据时，先把对象中的数据存入缓存中，再从缓冲中进行读取；对TestIO.out文件进行操作时，先把格式化后的信息输出到缓存中，再把缓存中的信息输出到文件中。
5区中，对Data.txt文件进行输出时，是先把基本类型的数据输出屋缓存中，再把缓存中的数据输出到文件中；对文件进行读取操作时，先把文件中的数据读取到缓存中，再从缓存中以基本类型的形式进行读取。注意in5.readDouble()这一行。因为写入第一个writeDouble()，所以为了正确显示。也要以基本类型的形式进行读取。
6区是通过RandomAccessFile类对文件进行操作。

目前网络上关于对象序列化的文章不少，但是我发现详细叙述用法和原理的文章太少。本人把自己经过经验总结和实际运用中的体会写成的学习笔记贡献给大家。希望能为整个java社区的繁荣做一点事情。
序列化的过程就是对象写入字节流和从字节流中读取对象。将对象状态转换成字节流之后，可以用java.io包中的各种字节流类将其保存到文件中，管道到另一线程中或通过网络连接将对象数据发送到另一主机。对象序列化功能非常简单、强大，在RMI、Socket、JMS、EJB都有应用。对象序列化问题在网络编程中并不是最激动人心的课题，但却相当重要，具有许多实用意义。
一：对象序列化可以实现分布式对象。主要应用例如：RMI要利用对象序列化运行远程主机上的服务，就像在本地机上运行对象时一样。
二：java对象序列化不仅保留一个对象的数据，而且递归保存对象引用的每个对象的数据。可以将整个对象层次写入字节流中，可以保存在文件中或在网络连接上传递。利用对象序列化可以进行对象的“深复制”，即复制对象本身及引用的对象本身。序列化一个对象可能得到整个对象序列。
从上面的叙述中，我们知道了对象序列化是java编程中的必备武器，那么让我们从基础开始，好好学习一下它的机制和用法。

java序列化比较简单，通常不需要编写保存和恢复对象状态的定制代码。实现java.io.Serializable接口的类对象可以转换成字节流或从字节流恢复，不需要在类中增加任何代码。只有极少数情况下才需要定制代码保存或恢复对象状态。这里要注意：不是每个类都可序列化，有些类是不能序列化的，例如涉及线程的类与特定JVM有非常复杂的关系。

序列化机制：

序列化分为两大部分：序列化和反序列化。序列化是这个过程的第一部分，将数据分解成字节流，以便存储在文件中或在网络上传输。反序列化就是打开字节流并重构对象。对象序列化不仅要将基本数据类型转换成字节表示，有时还要恢复数据。恢复数据要求有恢复数据的对象实例。ObjectOutputStream中的序列化过程与字节流连接，包括对象类型和版本信息。反序列化时，JVM用头信息生成对象实例，然后将对象字节流中的数据复制到对象数据成员中。下面我们分两大部分来阐述：

处理对象流：

（序列化过程和反序列化过程）

java.io包有两个序列化对象的类。ObjectOutputStream负责将对象写入字节流，ObjectInputStream从字节流重构对象。
我们先了解ObjectOutputStream类吧。ObjectOutputStream类扩展DataOutput接口。
writeObject()方法是最重要的方法，用于对象序列化。如果对象包含其他对象的引用，则writeObject()方法递归序列化这些对象。每个ObjectOutputStream维护序列化的对象引用表，防止发送同一对象的多个拷贝。（这点很重要）由于writeObject()可以序列化整组交叉引用的对象，因此同一ObjectOutputStream实例可能不小心被请求序列化同一对象。这时，进行反引用序列化，而不是再次写入对象字节流。
下面，让我们从例子中来了解ObjectOutputStream这个类吧。

// 序列化 today's date 到一个文件中.
    FileOutputStream f = new FileOutputStream("tmp");
    ObjectOutputStream s = new ObjectOutputStream(f);
    s.writeObject("Today");
    s.writeObject(new Date());
    s.flush();

现在，让我们来了解ObjectInputStream这个类。它与ObjectOutputStream相似。它扩展DataInput接口。ObjectInputStream中的方法镜像DataInputStream中读取Java基本数据类型的公开方法。readObject()方法从字节流中反序列化对象。每次调用readObject()方法都返回流中下一个Object。对象字节流并不传输类的字节码，而是包括类名及其签名。readObject()收到对象时，JVM装入头中指定的类。如果找不到这个类，则readObject()抛出ClassNotFoundException,如果需要传输对象数据和字节码，则可以用RMI框架。ObjectInputStream的其余方法用于定制反序列化过程。
例子如下：

//从文件中反序列化 string 对象和 date 对象
    FileInputStream in = new FileInputStream("tmp");
    ObjectInputStream s = new ObjectInputStream(in);
    String today = (String)s.readObject();
    Date date = (Date)s.readObject();

定制序列化过程:

序列化通常可以自动完成，但有时可能要对这个过程进行控制。java可以将类声明为serializable，但仍可手工控制声明为static或transient的数据成员。
例子：一个非常简单的序列化类。

public class simpleSerializableClass implements Serializable{
	String sToday="Today:";
	transient Date dtToday=new Date();
}

序列化时，类的所有数据成员应可序列化除了声明为transient或static的成员。将变量声明为transient告诉JVM我们会负责将变元序列化。将数据成员声明为transient后，序列化过程就无法将其加进对象字节流中，没有从transient数据成员发送的数据。后面数据反序列化时，要重建数据成员（因为它是类定义的一部分），但不包含任何数据，因为这个数据成员不向流中写入任何数据。记住，对象流不序列化static或transient。我们的类要用writeObject()与readObject()方法以处理这些数据成员。使用writeObject()与readObject()方法时，还要注意按写入的顺序读取这些数据成员。
关于如何使用定制序列化的部分代码如下：

//重写writeObject()方法以便处理transient的成员。
public void writeObject(ObjectOutputStream outputStream) throws IOException{
	outputStream.defaultWriteObject();//使定制的writeObject()方法可以
						利用自动序列化中内置的逻辑。
	outputStream.writeObject(oSocket.getInetAddress());
	outputStream.writeInt(oSocket.getPort());
}
//重写readObject()方法以便接收transient的成员。
private void readObject(ObjectInputStream inputStream) throws IOException,ClassNotFoundException{
	inputStream.defaultReadObject();//defaultReadObject()补充自动序列化
	InetAddress oAddress=(InetAddress)inputStream.readObject();
	int iPort =inputStream.readInt();
	oSocket = new Socket(oAddress,iPort);
	iID=getID();
	dtToday =new Date();
}

完全定制序列化过程:

如果一个类要完全负责自己的序列化，则实现Externalizable接口而不是Serializable接口。Externalizable接口定义包括两个方法writeExternal()与readExternal()。利用这些方法可以控制对象数据成员如何写入字节流.类实现Externalizable时，头写入对象流中，然后类完全负责序列化和恢复数据成员，除了头以外，根本没有自动序列化。这里要注意了。声明类实现Externalizable接口会有重大的安全风险。writeExternal()与readExternal()方法声明为public，恶意类可以用这些方法读取和写入对象数据。如果对象包含敏感信息，则要格外小心。这包括使用安全套接或加密整个字节流。到此为至，我们学习了序列化的基础部分知识。关于序
列化的高级教程，以后再述。

参考资料：http://java.sun.com/j2se/1.3/docs/guide/serialization/spec/serialTOC.doc.html

Command模式是最让我疑惑的一个模式,我在阅读了很多代码后,才感觉隐约掌握其大概原理,我认为理解设计模式最主要是掌握起原理构造,这样才对自己实际编程有指导作用.Command模式实际上不是个很具体,规定很多的模式,正是这个灵活性,让人有些confuse.

Command定义
不少Command模式的代码都是针对图形界面的,它实际就是菜单命令,我们在一个下拉菜单选择一个命令时,然后会执行一些动作.

将这些命令封装成在一个类中,然后用户(调用者)再对这个类进行操作,这就是Command模式,换句话说,本来用户(调用者)是直接调用这些命令的,如菜单上打开文档(调用者),就直接指向打开文档的代码,使用Command模式,就是在这两者之间增加一个中间者,将这种直接关系拗断,同时两者之间都隔离,基本没有关系了.

显然这样做的好处是符合封装的特性,降低耦合度,Command是将对行为进行封装的典型模式,Factory是将创建进行封装的模式,
从Command模式,我也发现设计模式一个"通病":好象喜欢将简单的问题复杂化, 喜欢在不同类中增加第三者,当然这样做有利于代码的健壮性 可维护性 还有复用性.

如何使用?
具体的Command模式代码各式各样,因为如何封装命令,不同系统,有不同的做法.下面事例是将命令封装在一个Collection的List中,任何对象一旦加入List中,实际上装入了一个封闭的黑盒中,对象的特性消失了,只有取出时,才有可能模糊的分辨出:

典型的Command模式需要有一个接口.接口中有一个统一的方法,这就是"将命令/请求封装为对象":

public interface Command {
　　public abstract void execute ( );
}



具体不同命令/请求代码是实现接口Command,下面有三个具体命令

public class Engineer implements Command {

　　public void execute( ) {
　　　　//do Engineer's command
　　}
}

public class Programmer implements Command {

　　public void execute( ) {
　　　　//do programmer's command
　　}
}

public class Politician implements Command {

　　public void execute( ) {
　　　　//do Politician's command
　　}
}




按照通常做法,我们就可以直接调用这三个Command,但是使用Command模式,我们要将他们封装起来,扔到黑盒子List里去:

public class producer{
　　public static List produceRequests() {
　　　　List queue = new ArrayList();
　　　　queue.add( new DomesticEngineer() );
　　　　queue.add( new Politician() );
　　　　queue.add( new Programmer() );
　　　　return queue;
　　}

}


这三个命令进入List中后,已经失去了其外表特征,以后再取出,也可能无法分辨出谁是Engineer 谁是Programmer了,看下面如何调用Command模式:

public class TestCommand {
　　public static void main(String[] args) {
　　　　
　　　　List queue = Producer.produceRequests();
　　　　for (Iterator it = queue.iterator(); it.hasNext(); )
　　　　　　　　//取出List中东东,其他特征都不能确定,只能保证一个特征是100%正确,
　　　　　　　　// 他们至少是接口Command的"儿子".所以强制转换类型为接口Command

　　　　　　　　((Command)it.next()).execute();
　　

　　}
}


由此可见,调用者基本只和接口打交道,不合具体实现交互,这也体现了一个原则,面向接口编程,这样,以后增加第四个具体命令时,就不必修改调用者TestCommand中的代码了.

理解了上面的代码的核心原理,在使用中,就应该各人有自己方法了,特别是在如何分离调用者和具体命令上,有很多实现方法,上面的代码是使用"从List过一遍"的做法.这种做法只是为了演示.

使用Command模式的一个好理由还因为它能实现Undo功能.每个具体命令都可以记住它刚刚执行的动作,并且在需要时恢复.

Command模式在界面设计中应用广泛.Java的Swing中菜单命令都是使用Command模式,由于Java在界面设计的性能上还有欠缺,因此界面设计具体代码我们就不讨论,网络上有很多这样的示例.

Template定义:
定义一个操作中算法的骨架,将一些步骤的执行延迟到其子类中.

其实Java的抽象类本来就是Template模式,因此使用很普遍.而且很容易理解和使用,我们直接以示例开始:

public abstract class Benchmark
{
　　/**
　　* 下面操作是我们希望在子类中完成
　　*/
　　public abstract void benchmark();

　　/**
　　* 重复执行benchmark次数
　　*/
　　public final long repeat (int count) {
　　　　if (count <= 0)
　　　　　　return 0;
　　　　else {
　　　　　　long startTime = System.currentTimeMillis();

　　　　for (int i = 0; i < count; i++)
　　　　　　benchmark();

　　　　long stopTime = System.currentTimeMillis();
　　　　return stopTime - startTime;
　　}
}
}


在上例中,我们希望重复执行benchmark()操作,但是对benchmark()的具体内容没有说明,而是延迟到其子类中描述:

public class MethodBenchmark extends Benchmark
{
　　/**
　　* 真正定义benchmark内容
　　*/
　　public void benchmark() {

　　　　for (int i = 0; i < Integer.MAX_VALUE; i++){
　　　 　　System.out.printtln("i="+i);　 　　
　　　 }
　　}
}


至此,Template模式已经完成,是不是很简单?看看如何使用:

Benchmark operation = new MethodBenchmark();
long duration = operation.repeat(Integer.parseInt(args[0].trim()));
System.out.println("The operation took " + duration + " milliseconds");



也许你以前还疑惑抽象类有什么用,现在你应该彻底明白了吧? 至于这样做的好处,很显然啊,扩展性强,以后Benchmark内容变化,我只要再做一个继承子类就可以,不必修改其他应用代码.

Builder模式定义:
将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示.

Builder模式是一步一步创建一个复杂的对象,它允许用户可以只通过指定复杂对象的类型和内容就可以构建它们.用户不知道内部的具体构建细节.Builder模式是非常类似抽象工厂模式,细微的区别大概只有在反复使用中才能体会到.

为何使用?
是为了将构建复杂对象的过程和它的部件解耦.注意: 是解耦过程和部件.

因为一个复杂的对象,不但有很多大量组成部分,如汽车,有很多部件:车轮 方向盘 发动机还有各种小零件等等,部件很多,但远不止这些,如何将这些部件装配成一辆汽车,这个装配过程也很复杂(需要很好的组装技术),Builder模式就是为了将部件和组装过程分开.

如何使用?
首先假设一个复杂对象是由多个部件组成的,Builder模式是把复杂对象的创建和部件的创建分别开来,分别用Builder类和Director类来表示.

首先,需要一个接口,它定义如何创建复杂对象的各个部件:

public interface Builder {

　　//创建部件A　　比如创建汽车车轮
　　void buildPartA();
　　//创建部件B 比如创建汽车方向盘
　　void buildPartB();
　　//创建部件C 比如创建汽车发动机
　　void buildPartC();

　　//返回最后组装成品结果 (返回最后装配好的汽车)
　　//成品的组装过程不在这里进行,而是转移到下面的Director类中进行.
　　//从而实现了解耦过程和部件
　　Product getResult();

}


用Director构建最后的复杂对象,而在上面Builder接口中封装的是如何创建一个个部件(复杂对象是由这些部件组成的),也就是说Director的内容是如何将部件最后组装成成品:

public class Director {

　　private Builder builder;

　　public Director( Builder builder ) {
　　　　this.builder = builder;
　　}
　　// 将部件partA partB partC最后组成复杂对象
　　//这里是将车轮 方向盘和发动机组装成汽车的过程
　　public void construct() {
　　　　builder.buildPartA();
　　　　builder.buildPartB();
　　　　builder.buildPartC();

　　}

}


Builder的具体实现ConcreteBuilder:
通过具体完成接口Builder来构建或装配产品的部件;
定义并明确它所要创建的是什么具体东西;
提供一个可以重新获取产品的接口:

public class ConcreteBuilder implements Builder {

　　Part partA, partB, partC;
　　public void buildPartA() {
　　　　//这里是具体如何构建partA的代码

　　};
　　public void buildPartB() {
　　　　//这里是具体如何构建partB的代码
　　};
　　 public void buildPartC() {
　　　　//这里是具体如何构建partB的代码
　　};
　　 public Product getResult() {
　　　　//返回最后组装成品结果
　　};

}


复杂对象:产品Product:

public interface Product { }


复杂对象的部件:

public interface Part { }



我们看看如何调用Builder模式:
ConcreteBuilder builder = new ConcreteBuilder();
Director director = new Director( builder );

director.construct();
Product product = builder.getResult();

Builder模式的应用
在Java实际使用中,我们经常用到"池"(Pool)的概念,当资源提供者无法提供足够的资源,并且这些资源需要被很多用户反复共享时,就需要使用池.

"池"实际是一段内存,当池中有一些复杂的资源的"断肢"(比如数据库的连接池,也许有时一个连接会中断),如果循环再利用这些"断肢",将提高内存使用效率,提高池的性能.修改Builder模式中Director类使之能诊断"断肢"断在哪个部件上,再修复这个部件.

Visitor定义
作用于某个对象群中各个对象的操作. 它可以使你在不改变这些对象本身的情况下,定义作用于这些对象的新操作.

在Java中,Visitor模式实际上是分离了collection结构中的元素和对这些元素进行操作的行为.

为何使用Visitor?
Java的Collection(包括Vector和Hashtable)是我们最经常使用的技术,可是Collection好象是个黑色大染缸,本来有各种鲜明类型特征的对象一旦放入后,再取出时,这些类型就消失了.那么我们势必要用If来判断,如:


Iterator iterator = collection.iterator()
while (iterator.hasNext()) {
　　 Object o = iterator.next();
　　 if (o instanceof Collection)
　　 　　 messyPrintCollection((Collection)o);
　　 else if (o instanceof String)
　　 　　 System.out.println("'"+o.toString()+"'");
　　 else if (o instanceof Float)
　　 　　 System.out.println(o.toString()+"f");
　　 else
　　 　　 System.out.println(o.toString());
}
在上例中,我们使用了 instanceof来判断 o的类型.

很显然,这样做的缺点代码If else if 很繁琐.我们就可以使用Visitor模式解决它.

如何使用Visitor?
针对上例,我们设计一个接口visitor访问者:

public interface Visitor
{
　　 public void visitCollection(Collection collection);
　　 public void visitString(String string);
　　 public void visitFloat(Float float);
}


在这个接口中,将我们认为Collection有可能的类的类型放入其中.

有了访问者,我们需要被访问者,被访问者就是我们Collection的每个元素Element,我们要为这些Element定义一个可以接受访问的接口(访问和被访问是互动的,只有访问者,被访问者如果表示不欢迎,访问者就不能访问),

我们定义这个接口叫Visitable,用来定义一个Accept操作,也就是说让Collection每个元素具备可访问性.

public interface Visitable
{
　　 public void accept(Visitor visitor);
}


好了,有了两个接口,我们就要定义他们的具体实现(Concrete class):

public class ConcreteElement implements Visitable
{
　　 private String value;
　　 public ConcreteElement(String string) {
　　 　　 value = string;
　　 }
　　 //定义accept的具体内容 这里是很简单的一句调用
　　 public void accept(Visitor visitor) {
　　 　　 visitor.visitString(this);
　　 }
}


再看看访问者的Concrete实现:

public class ConcreteVisitor implements Visitor
{
　　 //在本方法中,我们实现了对Collection的元素的成功访问
　　 public void visitCollection(Collection collection) {
　　 　　 Iterator iterator = collection.iterator()
　　 　　 while (iterator.hasNext()) {
　　 　　 　　 Object o = iterator.next();
　　 　　 　　 if (o instanceof Visitable)
　　 　　 　　 　　 ((Visitable)o).accept(this);
　　 　　 }

　　 public void visitString(String string) {
　　 　　 System.out.println("'"+string+"'");
　　 }

　　 public void visitFloat(Float float) {
　　 　　 System.out.println(float.toString()+"f");
　　 }
}




在上面的visitCollection我们实现了对Collection每个元素访问,只使用了一个判断语句,只要判断其是否可以访问.

至此,我们完成了Visitor模式基本架构.

使用Visitor模式的前提
对象群结构中(Collection) 中的对象类型很少改变,也就是说访问者的身份类型很少改变,如上面中Visitor中的类型很少改变,如果需要增加新的操作,比如上例中我们在ConcreteElement具体实现外,还需要新的ConcreteElement2 ConcreteElement3.

可见使用Visitor模式是有前提的,在两个接口Visitor和Visitable中,确保Visitor很少变化,变化的是Visitable,这样使用Visitor最方便.

如果Visitor也经常变化, 也就是说,对象群中的对象类型经常改变,一般建议是,不如在这些对象类中逐个定义操作.但是Java的Reflect技术解决了这个问题.

定义:
Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。

在很多操作中，比如建立目录 数据库连接都需要这样的单线程操作。

还有, singleton能够被状态化; 这样，多个单态类在一起就可以作为一个状态仓库一样向外提供服务，比如，你要论坛中的帖子计数器，每次浏览一次需要计数，单态类能否保持住这个计数，并且能synchronize的安全自动加1，如果你要把这个数字永久保存到数据库，你可以在不修改单态接口的情况下方便的做到。

另外方面，Singleton也能够被无状态化。提供工具性质的功能，

Singleton模式就为我们提供了这样实现的可能。使用Singleton的好处还在于可以节省内存，因为它限制了实例的个数，有利于Java垃圾回收（garbage collection）。

我们常常看到工厂模式中类装入器(class loader)中也用Singleton模式实现的,因为被装入的类实际也属于资源。

如何使用?
一般Singleton模式通常有几种形式:

public class Singleton {

　　private Singleton(){}

　　//在自己内部定义自己一个实例，是不是很奇怪？
　　//注意这是private 只供内部调用

　　private static Singleton instance = new Singleton();

　　//这里提供了一个供外部访问本class的静态方法，可以直接访问　　
　　public static Singleton getInstance() {
　　　　return instance; 　　
　　 }
}




第二种形式:

public class Singleton {

　　private static Singleton instance = null;

　　public static synchronized Singleton getInstance() {

　　//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次　　　 　
　　//使用时生成实例，提高了效率！
　　if (instance==null)
　　　　instance＝new Singleton();
　　return instance; 　　}

}




使用Singleton.getInstance()可以访问单态类。

上面第二中形式是lazy initialization，也就是说第一次调用时初始Singleton，以后就不用再生成了。

注意到lazy initialization形式中的synchronized，这个synchronized很重要，如果没有synchronized，那么使用getInstance()是有可能得到多个Singleton实例。关于lazy initialization的Singleton有很多涉及double-checked locking (DCL)的讨论，有兴趣者进一步研究。

一般认为第一种形式要更加安全些。

使用Singleton注意事项：
有时在某些情况下，使用Singleton并不能达到Singleton的目的，如有多个Singleton对象同时被不同的类装入器装载；在EJB这样的分布式系统中使用也要注意这种情况，因为EJB是跨服务器，跨JVM的。

我们以SUN公司的宠物店源码(Pet Store 1.3.1)的ServiceLocator为例稍微分析一下：

在Pet Store中ServiceLocator有两种，一个是EJB目录下；一个是WEB目录下，我们检查这两个ServiceLocator会发现内容差不多，都是提供EJB的查询定位服务，可是为什么要分开呢？仔细研究对这两种ServiceLocator才发现区别：在WEB中的ServiceLocator的采取Singleton模式，ServiceLocator属于资源定位，理所当然应该使用Singleton模式。但是在EJB中，Singleton模式已经失去作用，所以ServiceLocator才分成两种，一种面向WEB服务的，一种是面向EJB服务的。

Singleton模式看起来简单，使用方法也很方便，但是真正用好，是非常不容易，需要对Java的类 线程 内存等概念有相当的了解。

定义:提供创建对象的接口.

为何使用?
工厂模式是我们最常用的模式了,著名的Jive论坛 ,就大量使用了工厂模式，工厂模式在Java程序系统可以说是随处可见。

为什么工厂模式是如此常用？因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的，所以以后new时就要多个心眼，是否可以考虑实用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。

我们以类Sample为例， 如果我们要创建Sample的实例对象:

Sample sample=new Sample();

可是，实际情况是，通常我们都要在创建sample实例时做点初始化的工作,比如赋值 查询数据库等。

首先，我们想到的是，可以使用Sample的构造函数，这样生成实例就写成:

Sample sample=new Sample(参数);

但是，如果创建sample实例时所做的初始化工作不是象赋值这样简单的事，可能是很长一段代码，如果也写入构造函数中，那你的代码很难看了（就需要Refactor重整）。

为什么说代码很难看，初学者可能没有这种感觉，我们分析如下，初始化工作如果是很长一段代码，说明要做的工作很多，将很多工作装入一个方法中，相当于将很多鸡蛋放在一个篮子里，是很危险的，这也是有背于Java面向对象的原则，面向对象的封装(Encapsulation)和分派(Delegation)告诉我们，尽量将长的代码分派“切割”成每段，将每段再“封装”起来(减少段和段之间偶合联系性)，这样，就会将风险分散，以后如果需要修改，只要更改每段，不会再发生牵一动百的事情。

在本例中，首先，我们需要将创建实例的工作与使用实例的工作分开, 也就是说，让创建实例所需要的大量初始化工作从Sample的构造函数中分离出去。

这时我们就需要Factory工厂模式来生成对象了，不能再用上面简单new Sample(参数)。还有,如果Sample有个继承如MySample, 按照面向接口编程,我们需要将Sample抽象成一个接口.现在Sample是接口,有两个子类MySample 和HisSample .我们要实例化他们时,如下:

Sample mysample=new MySample();
Sample hissample=new HisSample();

随着项目的深入,Sample可能还会"生出很多儿子出来", 那么我们要对这些儿子一个个实例化,更糟糕的是,可能还要对以前的代码进行修改:加入后来生出儿子的实例.这在传统程序中是无法避免的.

但如果你一开始就有意识使用了工厂模式,这些麻烦就没有了.

工厂方法
你会建立一个专门生产Sample实例的工厂:

public class Factory{

　　public static Sample creator(int which){

　　//getClass 产生Sample 一般可使用动态类装载装入类。
　　if (which==1)
　　　　return new SampleA();
　　else if (which==2)
　　　　return new SampleB();

　　}

}


那么在你的程序中,如果要实例化Sample时.就使用

Sample sampleA=Factory.creator(1);

这样,在整个就不涉及到Sample的具体子类,达到封装效果,也就减少错误修改的机会,这个原理可以用很通俗的话来比喻:就是具体事情做得越多,越容易范错误.这每个做过具体工作的人都深有体会,相反,官做得越高,说出的话越抽象越笼统,范错误可能性就越少.好象我们从编程序中也能悟出人生道理?呵呵.

使用工厂方法 要注意几个角色，首先你要定义产品接口，如上面的Sample,产品接口下有Sample接口的实现类,如SampleA,其次要有一个factory类，用来生成产品Sample，如下图，最右边是生产的对象Sample：



进一步稍微复杂一点，就是在工厂类上进行拓展，工厂类也有继承它的实现类concreteFactory了。

抽象工厂
工厂模式中有: 工厂方法(Factory Method) 抽象工厂(Abstract Factory).

这两个模式区别在于需要创建对象的复杂程度上。如果我们创建对象的方法变得复杂了,如上面工厂方法中是创建一个对象Sample,如果我们还有新的产品接口Sample2.

这里假设：Sample有两个concrete类SampleA和SamleB，而Sample2也有两个concrete类Sample2A和SampleB2

那么，我们就将上例中Factory变成抽象类,将共同部分封装在抽象类中,不同部分使用子类实现，下面就是将上例中的Factory拓展成抽象工厂:

public abstract class Factory{

　　public abstract Sample creator();

　　public abstract Sample2 creator(String name);

}

public class SimpleFactory extends Factory{

　　public Sample creator(){
　　　　.........
　　　　return new SampleA
　　}

　　public Sample2 creator(String name){
　　　　.........
　　　　return new Sample2A
　　}

}

public class BombFactory extends Factory{

　　public Sample creator(){
　　　　......
　　　　return new SampleB
　　}

　　public Sample2 creator(String name){
　　　　......
　　　　return new Sample2B
　　}

}




从上面看到两个工厂各自生产出一套Sample和Sample2,也许你会疑问，为什么我不可以使用两个工厂方法来分别生产Sample和Sample2?

抽象工厂还有另外一个关键要点，是因为 SimpleFactory内，生产Sample和生产Sample2的方法之间有一定联系，所以才要将这两个方法捆绑在一个类中，这个工厂类有其本身特征，也许制造过程是统一的，比如：制造工艺比较简单，所以名称叫SimpleFactory。

在实际应用中，工厂方法用得比较多一些，而且是和动态类装入器组合在一起应用，

举例

我们以Jive的ForumFactory为例，这个例子在前面的Singleton模式中我们讨论过，现在再讨论其工厂模式:

public abstract class ForumFactory {

　　private static Object initLock = new Object();
　　private static String className = "com.jivesoftware.forum.database.DbForumFactory";
　　private static ForumFactory factory = null;

　　public static ForumFactory getInstance(Authorization authorization) {
　　　　//If no valid authorization passed in, return null.
　　　　if (authorization == null) {
　　　　　　return null;
　　　　on 单态模式
　　　　if (factory == null) {
　　　　　　synchronized(initLock) {
　　　　　　　　if (factory == null) {
　　　　　　　　　　　　......

　　　　　　　　　　try {
　　　　　　　　　　　　　　//动态转载类
　　　　　　　　　　　　　　Class c = Class.forName(className);
　　　　　　　　　　　　　　factory = (ForumFactory)c.newInstance();
　　　　　　　　　　}
　　　　　　　　　　catch (Exception e) {
　　　　　　　　　　　　　　return null;
　　　　　　　　　　}
　　　　　　　　}
　　　　　　}
　　　　}

　　　　//Now, 返回 proxy.用来限制授权对forum的访问
　　　　return new ForumFactoryProxy(authorization, factory,
　　　　　　　　　　　　　　　　　　　　factory.getPermissions(authorization));
　　}

　　//真正创建forum的方法由继承forumfactory的子类去完成.
　　public abstract Forum createForum(String name, String des cription)
　　throws UnauthorizedException, ForumAlreadyExistsException;

　　....

}






因为现在的Jive是通过数据库系统存放论坛帖子等内容数据,如果希望更改为通过文件系统实现,这个工厂方法ForumFactory就提供了提供动态接口:

private static String className = "com.jivesoftware.forum.database.DbForum}
　　　　//以下使用了SingletFactory";

你可以使用自己开发的创建forum的方法代替com.jivesoftware.forum.database.DbForumFactory就可以.

在上面的一段代码中一共用了三种模式,除了工厂模式外,还有Singleton单态模式,以及proxy模式,proxy模式主要用来授权用户对forum的访问,因为访问forum有两种人:一个是注册用户 一个是游客guest,那么那么相应的权限就不一样,而且这个权限是贯穿整个系统的,因此建立一个proxy,类似网关的概念,可以很好的达到这个效果.

看看Java宠物店中的CatalogDAOFactory:

public class CatalogDAOFactory {

　　/**

　　* 本方法制定一个特别的子类来实现DAO模式。
　　* 具体子类定义是在J2EE的部署描述器中。
　　*/

　　public static CatalogDAO getDAO() throws CatalogDAOSysException {

　　　　CatalogDAO catDao = null;

　　　　try {

　　　　　　InitialContext ic = new InitialContext();
　　　　　　//动态装入CATALOG_DAO_CLASS
　　　　　　//可以定义自己的CATALOG_DAO_CLASS，从而在无需变更太多代码
　　　　　　//的前提下，完成系统的巨大变更。

　　　　　　String className =(String) ic.lookup(JNDINames.CATALOG_DAO_CLASS);

　　　　　　catDao = (CatalogDAO) Class.forName(className).newInstance();

　　　　} catch (NamingException ne) {

　　　　　　throw new CatalogDAOSysException("
　　　　　　　　CatalogDAOFactory.getDAO: NamingException while
　　　　　　　　　　getting DAO type : \n" + ne.getMessage());

　　　　} catch (Exception se) {

　　　　　　throw new CatalogDAOSysException("
　　　　　　　　CatalogDAOFactory.getDAO: Exception while getting
　　　　　　　　　　DAO type : \n" + se.getMessage());

　　　　}

　　　　return catDao;

　　}

}


CatalogDAOFactory是典型的工厂方法，catDao是通过动态类装入器className获得CatalogDAOFactory具体实现子类，这个实现子类在Java宠物店是用来操作catalog数据库，用户可以根据数据库的类型不同，定制自己的具体实现子类，将自己的子类名给与CATALOG_DAO_CLASS变量就可以。

由此可见，工厂方法确实为系统结构提供了非常灵活强大的动态扩展机制，只要我们更换一下具体的工厂方法，系统其他地方无需一点变换，就有可能将系统功能进行改头换面的变化。


2.工厂模式的简单用例

工厂模式是J2EE核心模式中较简单的一种，听说Jive论坛中对数种设计模式有着广泛的应用，工厂模式也包括其中，本人就从该模式起步，希望有一天能对各种设计模式运用自如。

现给出一简单用例，模拟一火腿（Ham）生产工厂，工厂可以生产数种类型的Ham，那么在创建了一个工厂实例后，只需要告诉它请你生产何种Ham，它就会给你生产出来：
package test;

interface Ham { //定义接口，用于辅助实现工厂模式
    void show();//由Ham工厂生产出的各种Ham将有show()的能力
}
public class FatoryModule {//工厂类，用于产品多种不同种类的Ham
    public Ham getHam(String HamType) throws Exception{//工厂类对象生产Ham的动作
        if (HamType.equals("HamA")) {
            return new HamA();
        }
        else if (HamType.equals("HamB")) {
            return new HamB();
        }
        else if (HamType.equals("HamC")) {
            return new HamC();
        }
        else
            throw new Exception();//如果该工厂收到生产某种Ham的指令但暂不支持，则抛出异常
       
    }

    public static void main(String[] args) {//测试代码
        FatoryModule fatorymodule = new FatoryModule();
    try {
        Ham myHam = fatorymodule.getHam("HamB");//可以方便地创建各种类型的Ham，而程序结构和代码的修改量达到最小
        myHam.show();
    } catch (Exception ex) {
        ex.printStackTrace();//应进一步处理异常
    }
    }
}

class HamA implements Ham { //工厂中生产的一种产品HamA
    public void show() {
        System.out.println("You got a HamA.");
    }
}

class HamB implements Ham { //工厂生产的另一种产品HamB
    public void show() {
        System.out.println("You got a HamB.");
    }
}

class HamC implements Ham { //工厂生产的第三种产品HamC
    public void show() {
        System.out.println("You got a HamC.");
    }
}
        通过程序的演示我得到了以下结论：

        由于应用了工厂模式，我只需要告诉工厂对象给我生产一种什么样的Ham（即getHam()方法中的参数），便可以得到此类Ham，而不用写HamX  hamX=new HamX(); 要是有数十种不同的Ham对象需要在程序的不同地方被创建，那么使用工厂模式代码将显得简单而统一，每个需要不同Ham的地方仅是getHam()的参数不同。否则程序一旦需要扩展和维护，数十处的new语句将让人头痛。而如果需要添加新的Ham类型，只需要在工厂类中添加即可。
        我还这样理解：如果说每种Ham对象的创建都是一条生产线，那么我们用一个工厂将多个生产线封装起来了，从而用户就好比只与工厂传达室的人打交道，告诉他请你们工厂生产一种什么产品，而不是与每一条生产线打交道－－这样说来当然是有好处的。
        敬请各位发表评论：）