環境：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