环境：win32，Eclipse3.1，Designer_v4.1.1

1．  首先去http://www.swt-designer.com/左边的download菜单点击进去后下载Edition for Eclipse 3.1 & 3.2，下载后的文件名为Designer_v4.1.1_for_Eclipse3.1.zip

2．  然后在我的网络硬盘中下载破解文件: http://www.thefilehut.com/userfiles/gufen/forblog/swt.designer.pro.keygen.for.eclipse.3.1.rar

3．  解压后在cmd命令中敲入swt.ui.bat，运行后出现以下界面，输入框中的内容，然后点击Generate产生序列号和激活码。

如果你所使用的环境和版本不是win32，Eclipse3.1，Designer_v4.1.1，请参照http://blog.chinaz.com/u1/530/archives/2005/1789.shtml来进行破解。这种情况下需要：

a) 将该目录下的org.eclipse.swt.win32.win32.x86_3.1.0.jar和swt-win32-3138.dll删除

b)在Eclipse目录下找到swt.jar（名字视版本而定，eclipse3.1下是org.eclipse.swt.win32.win32.x86_3.1.0.jar） 和swt-win32-2135.dll（名字视版本而定，eclipse3.1下是swt-win32-3138.dll）2个文件，拷贝到swt.ui.bat所在的目录。

c)修改swt.ui.bat,如这样：

原来是: start javaw -cp SWTDesigner_2.0.0_Keygen.jar;org.eclipse.swt.win32.win32.x86_3.1.0.jar swtdesigner.keygen.SWTUI

修改为:start javaw -cp SWTDesigner_2.0.0_Keygen.jar;swt.jar swtdesigner.keygen.SWTUI

红色为修改的地方，然后运行后将Version填入你下载的swt-designer版本号即可产生注册码。

4.         将下载的Designer_v4.1.1_for_Eclipse3.1.zip插件安装到eclipse,如果你不知道如何安装插件请在google里搜索这方面的文章，应该很多的。我也是这样走过来的。

运行eclipse,打开window->preferences…->选择左边树形中的designer(如果没有这一项说明swt-designer插件没有安装成功)。->点击右下的“Registration and Activation”->弹出“Product Registration and Activation”框，用默认直接点击Next->这一步需要注意的是Name框中两个字符串之间要有个空格，他会认为一个是姓一个是名，否则Next按钮一直是灰的，其他随便填，email框中要合乎email格式就可以了->输入破解产生的序列号和激活码->显示“Activation is complete. Thank you.”表示破解成功

现在就可以免费使用swt-designer了

Win32下MyEclipse4.0破解

这个破解起来很简单，先去http://www.myeclipseide.com下载Myeclipse4.0,然后去http://www.thefilehut.com/userfiles/gufen/forblog/MyEclipse-4.0.0-GA.Keygen.zip下载破解。安装Myeclipse,之后解压破解文件后运行keygen.bat，产生一个key，之后在Myeclipse注册一下就可以了。Myeclipse我忘记什么地方注册了，好像装好Myeclipse后在preferences中的Myeclipse里点几下就会弹出来个框，把key copy过去确认就可以了。

以上破解方法仅供个人学习，请支持正版。(形式？)

     下边的条列只是简单的介绍，以便忘记了偶尔过来游览一下，详细的介绍请参阅：《Java模式》、《UML和模式应用-面向对象分析与设计导论》

1.         GRASP模式

GRASP是General Responsibility Assignment Software Pattern(通用指责分配软件模式)的缩写。

1)  专家模式(Expert)

解决方案：将职责分配给具有履行职责所需要的信息的类

通俗点就是：该干嘛干嘛去，别管别人的闲事或者我的职责就是搞这个，别的事不管。

举个简单的例子，如果有一个类是专门处理字符串相关的类，那么这个类只能有字符串处理相关的方法，而不要将日期处理的方法加进来。也就是提高软件高内聚一种原则。

2)  创建者(Creator)

解决方案：将创建一个类A的实例的职责指派给类B的实例，如果下列条件满足的话：

a)         B聚合了A对象

b)        B包含了A对象

c)        B纪录了A对象的实例

d)        B要经常使用A对象

e)         当A的实例被创建时，B具有要传递给A的初始化数据(也就是说B是创建A的实例这项任务的信息专家)

f)         B是A对象的创建者

如果以上条件中不止一条成立的话，那么最好让B聚集或包含A

通俗点就是：我要用你所以我来创建你，请不要让别人创建你

这个模式是支持低耦合度原则的一个体现

3)  高聚合度或高内聚(High Cohesion)

解决方案：分配一个职责的时候要保持类的高聚合度

聚合度或内聚度(cohesion)是一个类中的各个职责之间相关程度和集中程度的度量。一个具有高度相关职责的类并且这个类所能完成的工作量不是特别巨大，那么他就是具有高聚合度。

4)  低耦合度或低耦合(Low Coupling)

解决方案：在分配一个职责时要使保持低耦合度。

耦合度(coupling)是一个类与其它类关联、知道其他类的信息或者依赖其他类的强弱程度的度量。一个具有低(弱)耦合度的类不依赖于太多的其他类。

5)  控制者(Controller)

解决方案：将处理系统事件消息的职责分派给代表下列事物的类：

a)         代表整个“系统”的类（虚包控制者）

b)        代表整个企业或组织的类（虚包控制者）

c)        代表真实世界中参与职责（角色控制者）的主动对象类（例，一个人的角色）

d)        代表一个用况中所有事件的人工处理者类，通常用“<用例名>处理者”的方式命名（用例控制者）

这是一个控制者角色职责分配的原则，就是哪些控制应该分派给哪个角色。

6)多态

当相关的可选择的方法或行为随着类型变化时，将行为的职责-使用多态的操作-分配给那些行为变化的类型

也就是说尽量对抽象层编程，用多态的方法来判断具体应该使用那个类，而不是用if instanceof 来判断该类是什么接来执行什么。

7)纯虚构

一个纯虚构意味着虚构某些事物，而不是到了迫不得已我们才这样做。

例，我们的Sale类的数据要存入数据库，但是他必须和数据库接口相连接，如果将接口连接放入Sale类中势必增加该类的耦合度，所以我们可以虚构一个类来处理与数据库接口连接的问题。这个类就是我们虚构出来的一个事物。

8)中介者

将职责分配给一个中间对象以便在其他构件或服务之间仲裁，这样这些构件或服务没有被直接耦合。这个中间对象(intermediary)在其他构件或服务间创建一个中介者(Indirection)。这个中间对象也就事7)中的纯虚构。

9)不要和陌生人讲话

分配职责给一个客户端的直接对象以使它与一个间接对象进行协作，这样客户端无需知道这个间接对象。

这个模式-也被叫做(Demeter)准则。

       通俗点就是：只与你直接的朋友们通信

                            不要跟“陌生人”说话

每个软件单位对其他的单位都只有最少的知识，而且局限于那些与本单位密切相关的软件单位

2.         其他设计原则

1)“开-闭”原则（Open-Closed Principle，或者OCP）

一个软件实体应当对扩展开放，对修改关闭。

意思就是在设计一个模块的时候，应当使这个模块在不被修改的前提下被扩展。换言之，应当可以在不修改代码的情况下改变这个模块的行为。

2)里氏代换原则（Liskov Substitution Principle, 或者LSP）

这个就是尽量用多态的方法编程，也就是GRASP模式中的多态。

3)依赖倒转原则（Dependency Inversion Principle, 或者DIP）

依赖倒转原则讲的是：要依赖于抽象，不要依赖于具体

就是说我们尽量在抽象层进行控制编程，要针对接口编程，不要针对实现编程。

4)接口隔离原则（Interface Segregation Principle, 或者ISP）

使用多个专门的接口比使用单一的总接口要好。也就是，从一个客户类的角度来讲：一个类对另外一个类的依赖性应当是建立在最小的接口上的。

5)组合/聚合复用原则（Composition/Aggregation Principle, 或者CARP）

又叫合成复用原则。原则就是在一个新的对象里面使用一些已有的对象，使之成为新对象的一部分：新的对象通过向这些对象的委派达到复用已有功能的目的。也就是，要尽量使用类的合成复用，尽量不要使用继承

6)变与不变的分离
    更扩展一步,就是将不同变化的组件进行隔离.最简单的例子就是javabean中的存取器。它隔离了不变的接口和变化的内部属性。这方面体现最好的个人觉得就是eclipse，通过变化的插件，eclipse可以用来实现任何功能。

许多人都做过这样的事情，但是，我们到底声明了什么？回答通常是：一个String，内容是“Hello world!”。这样模糊的回答通常是概念不清的根源。如果要准确的回答，一半的人大概会回答错误。
这个语句声明的是一个指向对象的引用，名为“s”，可以指向类型为String的任何对象，目前指

1. 声明是什么?
String s = "Hello world!";

许多人都做过这样的事情，但是，我们到底声明了什么？回答通常是：一个String，内容是“Hello world!”。这样模糊的回答通常是概念不清的根源。如果要准确的回答，一半的人大概会回答错误。
这个语句声明的是一个指向对象的引用，名为“s”，可以指向类型为String的任何对象，目前指向"Hello world!"这个String类型的对象。这就是真正发生的事情。我们并没有声明一个String对象，我们只是声明了一个只能指向String对象的引用变量。所以，如果在刚才那句语句后面，如果再运行一句：

String string = s;

我们是声明了另外一个只能指向String对象的引用，名为string，并没有第二个对象产生，string还是指向原来那个对象，也就是，和s指向同一个对象。
2. String类的特殊性
1) String s1 = “Hello”;  //产生一个String ”Hello”对象,并产生该对象的一个别名s1来引用该对象
String s2 = “Hello”;  //又产生一个别名s2来引用上面的”Hello”对象
s1 == s2 = true;   //由于是同一个对象所以“==”返回为true
s1 = “World”;  //产生一个String ”World”对象, s1的引用不再指向“Hello”而是指向对象”World”
s1 == s2 = false;   //由于不是同一个对象所以“==”返回为false
s1 = “Hello”;  //同上面的String s2 = “Hello”; 现在s1又指向对象”Hello”, 因为JVM会自动根据栈中数据的实际情况来决定是否有必要创建新对象。
s1 == s2 = true;   //由于是同一个对象所以“==”又返回为true了
s1 = s1 + “World”;  //这时又产生一个对象”HelloWord”,s1不再指向”Hello”而是指向”HelloWord”
s1 == s2 = false;  //不是一个对象当然是false拉
s1 = s1+ "a"+"b"+"c"+…;  // String不停的创建对象,影响性能，这种易变的String用StringBuffer会得到更好的性能
StringBuffer s3 = new StringBuffer(“Hello”);
s3.append(“a”); //没有生成新的对象，而是将s3引用的对象内容改为”Helloa”

//说明: String类用来表示那些创建后就不会再改变的字符串，它是immutable的。而StringBuffer类用来表示内容可变的字符串，并提供了修改底层字符串的方法。
StingBuffer是一个可变的字符串，它可以被更改。同时StringBuffer是Thread safe的， 你可以放心的使用.

因为String被设计成一种安全的字符串， 避免了C/C++中的尴尬。因此在内部操作的时候会频繁的进行对象的交换， 因此它的效率不如StringBuffer。 如果需要频繁的进行字符串的增删操作的话最好用StringBuffer。 比如拼SQL文， 写共函。 另： 编绎器对String的+操作进行了一定的优化。
x = "a" + 4 + "c"
会被编绎成
x = new StringBuffer().append("a").append(4).append("c").toString()
但：
x = “a”;
x = x + 4;
x = x + “c”;
则不会被优化。 可以看出如果在一个表达式里面进行String的多次+操作会被优化， 而多个表达式的+操作不会被优化。
摘自：《Java API Using, Tips And Performance Tuning》
2) Integer、Boolean等wrapper类以及BigInteger、BigDecimal是immutable的，所以也有与String类似的地方，不过没有IntegerBuffer之类的东西。不过Float, Double比较特殊。如
T a1 = 10; //T代指Byte,Integer,Short,Long,Boolean。 注：应用了JDK5的AUTOBOXING
T a2 = 10;
if (a1 == a2)
 System.out.println(true);
else
 System.out.println(false);
这时总是true,和String有点类似

//Float时
Float i1 =  (float)10.0;
Float i2 =  (float)10.0;
if (i1==i2)
   System.out.println(true);
else
   System.out.println(false);
这时总是false

//Double时
Double i1 =  10.0;
Double i2 =  10.0;
if (i1==i2)
   System.out.println(true);
else
   System.out.println(false);
这时总是false

总之如果比较两个Wrapper类的值用equals，以免不必要的麻烦
3) 再看
String s1 = new String(“Hello”);
String s2 = new String(“Hello”);
s1 == s2 = false;
//因为new的时候JVM不管heap中有没有”Hello”对象都会产生一个新的”Hello”对象
String s3 = “Hello”; //重新创建对象”Hello”, 并令s3指向对象”Hello”
s3 == s1 = false; //不同对象当然false
String s4 = “Hello”;
s3 == s4 = true;  //故伎重演，jvm清楚的知道哪些用了new，哪些没用new

3. 方法的参数传递中都是以reference传递，而primitive传递的是副本，但如果传递的是Integer、Boolean等wrapper类和String类的Object则是以immutable方式传递。示例：
import java.awt.Point;
class HelloWorld
{
  public static void modifyPoint(Point pt, String j, int k, Integer m, Boolean b)
  {
    pt.setLocation(5,5);                                     
    j = "15";
    k = 25;
    m = 35;
    b = true;
    System.out.println("During modifyPoint " + "pt = " + pt +
                       " and j = " + j+ " and k = "+ k+
                       " and m = "+ m+ " and b = "+ b);
  }

  public static void main(String args[])
  {
    Point p = new Point(0,0);                                
    String i = "10";
    int k = 20;
    Integer m = 30;
    Boolean b = false;
    System.out.println("Before modifyPoint " + "p = " + p +
                       " and i = " + i+ " and k = "+ k+
                       " and m = "+ m+ " and b = "+ b);
    modifyPoint(p, i, k, m, b);                                       
    System.out.println("After modifyPoint " + "p = " + p +
                       " and i = " + i+ " and k = "+ k+
                       " and m = "+ m+ " and b = "+ b);
  }
}
输出结果：
Before modifyPoint p = java.awt.Point[x=0,y=0] and i = 10 and k = 20 and m = 30 and b = false
During modifyPoint pt = java.awt.Point[x=5,y=5] and j = 15 and k = 25 and m = 35 and b = true
After modifyPoint p = java.awt.Point[x=5,y=5] and i = 10 and k = 20 and m = 30 and b = false
4. final作用于基本类型变量则该变量为恒常量；final作用于对象类型变量则该对象reference为恒量；final作用于方法则该方法不能被覆盖；final作用于class则该class不能被继承。
final使得被修饰的变量"不变"，但是由于对象型变量的本质是“引用”，使得“不变”也有了两种含义：引用本身的不变，和引用指向的对象不变。

引用本身的不变：
final StringBuffer a=new StringBuffer("immutable");
final StringBuffer b=new StringBuffer("not immutable");
a=b;//编译期错误

引用指向的对象不变：
final StringBuffer a=new StringBuffer("immutable");
a.append(" broken!"); //编译通过

可见，final只对引用的“值”(也即它所指向的那个对象的内存地址)有效，它迫使引用只能指向初始指向的那个对象，改变它的指向会导致编译期错误。至于它所指向的对象的变化，final是不负责的。这很类似==操作符：==操作符只负责引用的“值”相等，至于这个地址所指向的对象内容是否相等，==操作符是不管的。

理解final问题有很重要的含义。许多程序漏洞都基于此----final只能保证引用永远指向固定对象，不能保证那个对象的状态不变。在多线程的操作中,一个对象会被多个线程共享或修改，一个线程对对象无意识的修改可能会导致另一个使用此对象的线程崩溃。一个错误的解决方法就是在此对象新建的时候把它声明为final，意图使得它“永远不变”。其实那是徒劳的。
5. 怎样初始化
本问题讨论变量的初始化，所以先来看一下Java中有哪些种类的变量。
1). 类的属性，或者叫值域
2). 方法里的局部变量
3). 方法的参数

对于第一种变量，Java虚拟机会自动进行初始化。如果给出了初始值，则初始化为该初始值。如果没有给出，则把它初始化为该类型变量的默认初始值。

primitive类型默认值
boolean: false
char: '\u0000'  对于未初始化的char c, c == ‘\u0000’ = true
byte: 0
short: 0
int: 0
long: 0
float: 0.0
double: 0.0
object reference: null
array: null
注意数组本身也是对象，所以没有初始化的数组引用在自动初始化后其值也是null。

对于两种不同的类属性，static属性与instance属性，初始化的时机是不同的。instance属性在创建实例的时候初始化，static属性在类加载，也就是第一次用到这个类的时候初始化，对于后来的实例的创建，不再次进行初始化。

对于第二种变量，必须明确地进行初始化。如果再没有初始化之前就试图使用它，编译器会抗议。如果初始化的语句在try块中或if块中，也必须要让它在第一次使用前一定能够得到赋值。也就是说，把初始化语句放在只有if块的条件判断语句中编译器也会抗议，因为执行的时候可能不符合if后面的判断条件，如此一来初始化语句就不会被执行了，这就违反了局部变量使用前必须初始化的规定。但如果在else块中也有初始化语句，就可以通过编译，因为无论如何，总有至少一条初始化语句会被执行，不会发生使用前未被初始化的事情。对于try-catch也是一样，如果只有在try块里才有初始化语句，编译部通过。如果在 catch或finally里也有，则可以通过编译。总之，要保证局部变量在使用之前一定被初始化了。所以，一个好的做法是在声明他们的时候就初始化他们，如果不知道要出事化成什么值好，就用上面的默认值吧！

其实第三种变量和第二种本质上是一样的，都是方法中的局部变量。只不过作为参数，肯定是被初始化过的，传入的值就是初始值，所以不需要初始化。
6. 尽量使用多态(polymorphism)特性而不是instanceof
7. 一旦不需要对象，尽量显式的使之为null
8. 对象之间的”=”赋值操作乃是赋值的reference, 即左边的对象也指向右边的对象，只是该reference多了一个别名而已。
9. “==”和equals()的区别
==操作符专门用来比较变量的值是否相等。比较好理解的一点是：
int a=10;
int b=10;
则a==b将是true。
但不好理解的地方是：
String a=new String("foo");
String b=new String("foo");
则a==b将返回false。

根据前一帖说过，对象变量其实是一个引用，它们的值是指向对象所在的内存地址，而不是对象本身。a和b都使用了new操作符，意味着将在内存中产生两个内容为"foo"的字符串，既然是“两个”，它们自然位于不同的内存地址。a和b的值其实是两个不同的内存地址的值，所以使用"=="操作符，结果会是 false。诚然，a和b所指的对象，它们的内容都是"foo"，应该是“相等”，但是==操作符并不涉及到对象内容的比较。
对象内容的比较，正是equals方法做的事。

看一下Object对象的equals方法是如何实现的：
boolean equals(Object o){

return this==o;

}
Object 对象默认使用了==操作符。所以如果你自创的类没有覆盖equals方法，那你的类使用equals和使用==会得到同样的结果。同样也可以看出， Object的equals方法没有达到equals方法应该达到的目标：比较两个对象内容是否相等。因为答案应该由类的创建者决定，所以Object把这个任务留给了类的创建者。

看一下一个极端的类：
Class Monster{
private String content;
...
boolean equals(Object another){ return true;}

}
我覆盖了equals方法。这个实现会导致无论Monster实例内容如何，它们之间的比较永远返回true。

所以当你是用equals方法判断对象的内容是否相等，请不要想当然。因为可能你认为相等，而这个类的作者不这样认为，而类的equals方法的实现是由他掌握的。如果你需要使用equals方法，或者使用任何基于散列码的集合（HashSet,HashMap,HashTable），请察看一下java doc以确认这个类的equals逻辑是如何实现的。
10. 不要依赖equals()的缺省实现
11. 一个equals()的实现模版
class Golfball
{
  private String brand;
  private String make;
  private int compression;

  public boolean equals(Object obj)
  {

    if (this == obj)
      return true;

    if (obj != null && getClass() == obj.getClass())
    {
      Golfball gb = (Golfball)obj;  //Classes are equal, downcast.
      if (brand.equals(gb.brand()) &&  //Compare attributes.
          make.equals(gb.make()) &&
          compression == gb.compression())
      {
        return true;
      }
    }
    return false;
  }
}
注意getClass() == obj.getClass()的限制，如果判断必须相等则无法比较基类和子类是否相等,完全不同的类不用考虑，完全没有可比性，除了特殊需要或很糟糕的程序。
12. 实现equals()应优先考虑使用getClass()
13. 如果某个基类我们自己实现了equals()，在它的子类中要覆盖此方法，最好调用super.equals()唤起base class的相关行为,然后再实现子类域的比较。
Example:
  public boolean equals(Object obj)
  {
    if (this == obj)                                          //1
      return true;

    if (obj != null && getClass() == obj.getClass() &&        //2
        super.equals(obj))                                    //3
    {
      MyGolfball gb = (MyGolfball)obj;  //Classes equal, downcast.
      if (ballConstruction == gb.construction())  //Compare attrs.
        return true;
    }
    return false;
  }
14. 如果要在base class与derived class之间应运equals(),可以考虑instanceof来代替getClass()。对此论题的详细讨论参见:Practical Java, Practice 14
15. instanceof什么东西？
instanceof是Java的一个二元操作符，和==，>，<是同一类东东。由于它是由字母组成的，所以也是Java的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据。举个例子：

String s = "I AM an Object!";
boolean isObject = s instanceof Object;

我们声明了一个String对象引用，指向一个String对象，然后用instancof来测试它所指向的对象是否是Object类的一个实例，显然，这是真的，所以返回true，也就是isObject的值为True。
instanceof有一些用处。比如我们写了一个处理账单的系统，其中有这样三个类：

public class Bill {//省略细节}
public class PhoneBill extends Bill {//省略细节}
public class GasBill extends Bill {//省略细节}

在处理程序里有一个方法，接受一个Bill类型的对象，计算金额。假设两种账单计算方法不同，而传入的Bill对象可能是两种中的任何一种，所以要用instanceof来判断：

public double calculate(Bill bill) {
if (bill instanceof PhoneBill) {
//计算电话账单
}
if (bill instanceof GasBill) {
//计算燃气账单
}
...
}
这样就可以用一个方法处理两种子类。

然而，这种做法通常被认为是没有好好利用面向对象中的多态性。其实上面的功能要求用方法重载完全可以实现，这是面向对象变成应有的做法，避免回到结构化编程模式。只要提供两个名字和返回值都相同，接受参数类型不同的方法就可以了：

public double calculate(PhoneBill bill) {
//计算电话账单
}

public double calculate(GasBill bill) {
//计算燃气账单
}

所以，使用instanceof在绝大多数情况下并不是推荐的做法，应当好好利用多态。
16. 认真对待异常。
1).在方法体用throws子句抛出异常时尽量包括所有出现的异常，而不是仅仅抛出base exception.
2).在super class中定义的方法抛出某个异常，如果在deriver class中要override该方法，那么overriding method必须：
a. 不抛出任何异常
b. 抛出和super class 中同样的异常
c. 抛出和super class 中异常的deriver class
如果super class中定义的方法没有抛出异常，但deriver class中的override的方法会产生异常，必须自己内部解决
 3).好好利用finally功能。一般只要有finally，它总是会被执行，除非在try中用System.exit(0)或者在try块执行期间强行拔掉电源。finally被执行有三种情况：
a. 抛出异常
b. try正常结束
c. 在try中执行了return, break, continue而引起离开try的操作
尤其注意c.如果方法中在try块return 1,而在finally块return 2,则最终永远是2，因此尽量避免在try中使用return, break, continue，要么确保在finally中不会改变返回值
 4).不要在循环体中使用try,因为在无JIT的JVM中将大大降低性能，而且这也是良好的编程习惯
 5).不要将异常用于控制流程，而是仅仅用于会发生错误的地方
 6).不要每逢出错就使用异常，尽量使用传统的方法判断变量的有效性
17. 关于不可变类(Immutable class),如String、Byte、Integer、Short、Long、Float、Double、BigInteger、BigDecimal等，它们之所以能将同一值自动地指向同一引用，实际上是它们实现了静态工厂方法。

目前我就用了eclipse下访问derby的3个插件：

1)        ibm和apache的两个插件一起使用，安装后在java项目点击右键后出现“Apache Derby”,里面有一个菜单“Add Apache Derby nature”,点击后将出现start、ij、sysinfo工具，这个插件就这些东西。

2)       用Quantum或dbedit插件访问derby.dbedit插件比较强大些，可以可视的进行表的alert操作，好像没有proc,view的显示界面。Quantum有proc,view的显示界面，但是没法可视进行添加表功能。两个都有可视sql edit界面。我没搞定如何用derby的jdbc进行对数据库的访问，只能用db2的jdbc访问，url为：jdbc:db2://localhost:1527/"C:\IBM\Cloudscape_10.0\demo\databases\toursDB"

1)选择菜单Window->Preferences->MyEclipse->Application Servers->Weblogic 8，配置项目如下：
BEA home directory: 选择Bea的安装目录
Weblogic installation directory:现在BEA下面的weblogic81目录
Admin username:输入上面在配置过程中设的用户名
Admin password:输入刚才设的密码
Execution domain root:选择BEA下user_projects\domains目录下上面第一步创建的目录
Execution domain name:输入上面那个目录的名称
Execution server name:输入上一步的那个Congfiguration Name
Hostname:PortNumber:输入IP地址和监听的端口
Security policy file:输入BEA安装目录下的\weblogic81\server\lib\weblogic.policy
(2)在Weblogic 8下面配置JDK，在WLS JDK name那里选择新建，弹出的对话框中选择BEA下面的JDK安装路径，输入一个名字确定就可以；在Optional Java VM arguments对话框里面输入-ms64m -mx64m -Djava.library.path="D:/BEA/weblogic81/server/bin" -Dweblogic.management.discover=false -Dweblogic.ProductionModeEnabled=false
(3在Weblogic 8下面配置Paths，加入BEA安装路径下/weblogic81/server/lib中的webservices.jar和weblogic.jar两个包。如果需要其他的包，也在这里加入。

PS:我使用的环境是Eclipse 3.0.3和MyEclipse3.8.4，操作系统是Windows 2000

1. 安装jdk5.0, jre5.0，之后设置环境变量
增加如下系统环境变量(注：jdk安装目录D:\jdk15)。
java_home= D:\jdk15
classpath=.;%java_home%\lib\tools.jar;%java_home%\lib\dt.jar;
path系统变量中增加%java_home%\bin;(尽量加在最前面)
2. 安装Tomcat
    一路“下一步”安装完成，途中有确认jre路径界面需要注意。启动Tomcat服务后在游览器中敲入http://127.0.0.1:8080/或者http://localhost:8080/后出现传说中丑陋的三脚Cat即安装成功。
  增加如下系统环境变量
  CATALINA_HOME= C:\Program Files\Apache Software Foundation\Tomcat 5.5（我是默认安装）
classpath中增加以下内容
%CATALINA_HOME%\common\lib\servlet-api.jar;%CATALINA_HOME%\common\lib\jasper-runtime.jar;%CATALINA_HOME%\common\lib\jsp-api.jar;
TOMCAT的一些JAVA CLASS都在%CATALINA_HOME%\common\lib，如果jsp,bean编译不过去，看看错误如果有not found class之类的，就去%CATALINA_HOME%\common\lib下找，找到后加至classpath中就可以了。
3. 发布第一个jsp：HelloWord
Tomcat所有的程序均发布在D:\Program Files\Apache Software Foundation\Tomcat 5.5\webapps路径的各个目录里，在2中看见的丑陋猫就是ROOT下的index.jsp。
在webapps下建立一个目录mytest,然后拷贝ROOT下的WEB-INF目录到mytest目录，这里面是一些配置文件。之后在mytest中建立文件HelloWorld.jsp，文件内容为：
<%@ page language="java" %>
<html>
 <head><title></title></head>
 <body>
  <center>
   <%! String str = new String("HelloWorld!"); %>
   <font color="blue"><%= str %> </font><br>
  </center>
 </body>
</html>
保存后在游览器中输入http://127.0.0.1:8080/mytest/HelloWorld.jsp, 如果没有意外的话应该执行成功，表示已正式进入jsp世界，不行重起tomcat。
4. 发布第一个servlet
 在mytest\WEB-INF下新建classes目录，然后在classes下新建目录test,test目录中新建文件HelloServlet.java。内容为：
package test;
//因为我们的包为test所以以上一句必须有，如果直接是在classes下新建//HelloServlet.java，则不需要声明包。
import java.io.*;
import java.util.*;
//导入servlet包
import javax.servlet.*;
public class HelloServlet extends GenericServlet
{ 
 public void init(ServletConfig config)throws ServletException
 {
  super.init(config);
  //调用父类的初始化方法；也可以加入自己需要的初始化代码。
 } 
 public void destroy(){
  //destroy方法中加入一些做最后清理工作的代码；
} 
 public String getServletInfo(){
  return "This servlet is a simple Servlet's example.";
  //返回此servlet的信息 ；
 } 
 public void service(ServletRequest req,ServletResponse res)
   throws ServletException,IOException
 {  //service是最主要的方法，提供服务
  //获得服务器当前时间。
  Date today=new Date();

  //获得响应用户请求的输出流，以反馈执行结果；
  ServletOutputStream out=res.getOutputStream();

  //通过输出流向客户端写回了一个HTML文件；
  out.println("<html><head><title>HelloServlet.java</title></head><body>");
  out.println("Hello,this is my first test.+<BR>");
  out.println("Today is "+today.toString()+"<BR>");
  out.println(getServletInfo()+"<BR>");
 }
}

 之后编译HelloServlet.java ，在命令行中敲入javac HelloServlet.java。在游览器中查看该Servlet之前需要改动mytest\WEB-INF\web.xml文件，建立HelloServlet的映射。将以下代码拷贝至web.xml文件。
    <servlet>
        <servlet-name>HelloServlet</servlet-name>
        <servlet-class>test.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>HelloServlet</servlet-name>
        <url-pattern>/servlet/HelloServlet</url-pattern>
</servlet-mapping>
保存后在游览器地址栏中敲入http://localhost:8080/mytest/servlet/HelloServlet后出现Hello,this is my first test.+等字样表示已经进入Servlet世界。
注意我们将HelloServlet映射为/servlet/HelloServlet所以在http://localhost:8080/mytest后敲入的是/servlet/HelloServlet；如果我们直接映射为/HelloServlet，即改为<url-pattern> /HelloServlet</url-pattern>，则在游览器地址栏中敲入的应该是http://localhost:8080/mytest/HelloServlet
5. 发布第一个bean(这个例子应用了jsp页面)
1) 先在C:\Program Files\Apache Software Foundation\Tomcat 5.5\webapps\mytest下建立一个htm文档transPara.htm
内容为：
<html>
 <head>
  <title>transPara.htm</title>
 </head>
<body>
 <form method="POST" action="acceptPara.jsp">
    <p align="center">
  姓 名：<input type="text" name="name" size="20"><br>
    年 龄：&nbsp;&nbsp;&nbsp; <input type="text" name="age" size="15"><br>
    性 别：&nbsp;&nbsp;&nbsp;
   <input type="radio" value="male" checked name="sex">
    男&nbsp;&nbsp;&nbsp;&nbsp; 
     <input type="radio" name="sex" value="female">女</p>
    <p align="center">
   <input type="submit" value="submit" name="submit">
     <input type="reset" value="reset" name="reset"></p>
 </form>
</body>
</html>
2) 在C:\Program Files\Apache Software Foundation\Tomcat 5.5\webapps\mytest下建立一个jsp文档acceptPara.jsp
内容为：
<html>
<%@ page import="test.acceptPara" contentType="text/html;charset=gb2312"%>
<jsp:useBean id="atest" class="test.acceptPara"/>
<head><title>acceptPara.jsp</title></head>
<body>
<jsp:setProperty name="atest" property="*"/>
Value of property "name" :
<jsp:getProperty name="atest" property="name"/><br>
Value of property "age" :
<jsp:getProperty name="atest" property="age"/><br>
Value of property "sex" :
<jsp:getProperty name="atest" property="sex"/><br>
Value of property "submit" :
<jsp:getProperty name="atest" property="submit"/><br>
</body>
</html>
3) 在C:\Program Files\Apache Software Foundation\Tomcat 5.5\webapps\mytest\WEB-INF\classes\test下建立bean: acceptPara.java
内容为：
package test;

public class acceptPara{
 String name;
 int age;
 String sex;
 String submit;
 
 public void setName(String value){
  name=value;
 } 
 public String getName(){
  return name;
 } 
 public void setAge(int value){
  age=value;
 } 
 public int getAge(){
  return age;
 } 
 public void setSex(String value){
  sex=value;
 } 
 public String getSex(){
  return sex;
 } 
 public void setSubmit(String value){
  submit=value;
 } 
 public String getSubmit(){
  return submit;
 }
 public void acceptPara(){}
}
编译该bean,之后在游览器地址栏中敲入http://localhost:8080/mytest/transPara.htm，我们可以看见有姓名、年龄、性别几个表单，输入各个项后点击submit就可以看到我们刚才输入的结果，大概返回结果如下：
Value of property "name" : Joson
Value of property "age" : 23
Value of property "sex" : male
Value of property "submit" : submit