一般來說。ant的任務都是要寫一個build.xml文件，然后刪刪改改，最后運行ant target。這自是正途。但是有時候，如果你需要的就是簡單試驗一下某個task，或者就想拿某個ant task當成shell命令的話，就不方便了。

在Neptune這個工具里面，附帶了一個shell。這個shell允許交互執行Neptune的Command和Ant的Task。可以在這里下載：
http://docs.codehaus.org/display/JASKELL/Downloads

下面簡要介紹一下怎么用：

啟動Neptune shell很簡單。按照要求安裝完了之后（就是設置一個NEPTUNE_HOME和PATH環境變量），運行：
shell啟動后，你可以看見：
這個">"是命令提示符。現在你可以輸入命令了。

先看看最簡單的ant echo任務。xml語法是這樣的：
對應的neptune語法是

稍微解釋一下：
1。所有ant命令都在ant這個namespace里面。
2。xml的尖括號換成大括號。大括號在jaskell語言里面表示一個tuple。
3。exec函數用來執行一個命令。如果沒有exec，ant.echo只是生成一個命令對象，但不執行。這樣做得好處是，你可以用變量臨時存儲這些命令對象，可以把他們存在任意的對象或者數組中，等到真正需要執行的時候再運行。
4。"->"這個函數用來以先參數后函數的循序調用函數，相當于exec(ant.echo{...})，語法上有的時候顯得更漂亮些。



再來看個復雜點的。前兩天我發現需要把某個目錄下所有反編譯出來的jad文件改名成java文件。dos的rename命令居然不支持。于是我就祭起法寶：

這個東西定義了一個函數，接下來，我就可以拿rename當作一個簡潔的命令了：


后來，我把這個rename函數稍微完善了一下，增加了一個recursive參數來控制是否處理子目錄，缺省值是false，給dir設置當前目錄為缺省值。代碼放在一個可以重用的腳本文件里面。現在可以這樣做了。先把函數加載進來：


然后調用：

呵呵。

這個工具可以調用任意的ant任務。還有很多好用的函數。具體請見：
http://docs.codehaus.org/display/JASKELL/Neptune

這兩天完善了我的jaskell語言的一個shell。

這個shell雖然是jaskell的，但是也可以作為一個交互式執行java代碼的解釋器。對于想快速地試試某個api比較有用。

相比于eclipse scrapebook，它的好處是更方便，而且，jaskell的一些函數式的特性讓你可以寫出更加簡潔的代碼。

下面舉幾個例子：

輕松玩Swing

打開shell，它顯示這樣：
然后假設你要運行一下javax.swing.JOptionPane.showInputDialog()函數的話，你可以這樣寫：
回車兩下（第一下，就是簡單折行，因為你可以接著寫下一行代碼，只有連續兩下折行，shell才認為你是要執行）
結果就會出現一個簡單的swing對話框。在對話框里面輸入年齡“13"，回車，
shell里面就會顯示：13。


這里面，一點需要注意的，java方法調用不用圓括號，而是方括號。你可以把這個理解為一個reflection調用，傳遞的永遠都是一個數組。

下面，假設你想重復地使用JOptionPane這個類，使用showInputDialog, showConfirmDialog這類的方法，總這么寫javax.swing.JOptionPane也夠麻煩的。我們可以簡化它：
當你回車兩次后，shell在"=>"提示符后面自動顯示這個表達式的值："class javax.swing.JOptionPane"。

下面我們可以重復使用dialog變量了。在這之前，我們可能想看看JOptionPane到底都支持什么靜態方法，我們可以用"?"來讓shell告訴我們
這個"?"不是jaskell語言的一部分，而是shell的命令，所以不需要回車兩次。回車，shell就會把JOptionPane的所有方法都列出來。

然后假設我們選擇showMessageDialog，可以這樣寫：
然后，一個"hello world"的對話框就彈了出來（看不見？找一找。它可能被藏在你的當前窗口后面了。）

更簡化一點，假設我要重復showMessageDialog若干遍，我可以這樣寫：
這個表達式的值是一個接受一個參數的，叫做say的函數。

下面你可以say很多東西啦：
等等等等。



傻瓜多線程

好，看過了JOptionPane，我們來看看多線程。下面是用這個語言怎么啟動一個線程：
這里面Thread.new大概不需要解釋。這里對構造函數的調用是Ruby風格的ClassName.new，而不是java的new ClassName。

構造函數也需要用一個list來傳遞參數。我們這里傳遞的是一個Runnable對象。
用來實現Runnable接口的是一個匿名函數，這個函數不管參數是什么，一旦調用，就println一下。

implements 是一個函數，它負責用一個函數來動態生成一個實現某接口的proxy出來。它前面的那個反向單引號表示把一個函數以中綴語法調用，所以 (somefunction `implements Runnable)等價于implements(somefunction, Runnable)。

"\"符號是lamda函數表示法。"->"符號前面的是函數參數，后面的是函數體。這里因為我們不使用這個參數，所以用"_"這個通配符。

最后，我們調用start[]方法來執行這個線程。


我們還可以用標準的"const"函數來讓代碼更簡短一點。"const x"語義上完全等價于"\_->x"。另外，我們也可以用java風格的new操作符函數來寫，jaskell對兩者都支持的：


然后，考慮到重用，我們可以這樣，先把System.out.println搞短一點，每次敲這么長太麻煩：

（實際上，println函數是系統已經缺省就定義好的了。你完全沒有必要自己定義println就可以直接用了。這里只是演示一下怎么自己定義函數）


然后，把那段啟動線程的代碼寫成函數：

好了，下面我們可以任意啟動線程做事情了：

最后一個say "nice!"，如果不用單獨線程的話，運行后這個對話框將阻塞當前線程。現在用run來運行它，就不會阻塞了。


今天你fp了嗎？

最后再隨便看看jaskell作為函數式語言的本分所能做的一些事。

foreach函數：

這個函數把1,2,"hello"三個都打印一遍。

這個函數把數字1到100按順序打印一遍。

map函數：
這個函數把一個字符串列表轉換成一個整數列表。


filter函數：

這個代碼把1到100中所有小于10的整數都取出來。

filter函數的第一個參數是一個函數，這個函數對列表中的每一個元素都進行判斷，返回true或者false。

find函數：

這個代碼在列表中尋找整數2，如果找到，返回找到的位置（0為第一個）


lookup函數：

這個代碼在列表中尋找第一個符合x*x>x+50的元素，找到就返回位置。

@函數：

上面我們知道找到的數字是在位置7，可以用@來得到位置7的值：

好，這個數是8。


sum函數：


注意，最難的來了！
fold函數：

這個fold函數以1為初始值，然后對每個列表元素，把它和當前值做乘法，用結果更新當前值，最后把計算結果返回。所以這段代碼實際上做的就是把從1到5乘起來。
(*)是一個乘法函數。

你也可以用自己寫的：
一樣的。


行了，差不多了。下載在：

http://dist.codehaus.org/yan/distributions/jaskell.zip

把jar文件都放到你的classpath里面，然后運行jfun.jaskell.shell.Shell類就行了。

昨天在千年妖精麗晶大賓館，看見sparkle同學抱怨Spring的transaction template不好用。因為一些我沒有問的原因，他們不能使用聲明式事務，所以就只剩下兩個選擇：
1。直接用hibernate事務。
2。用spring的TransactionTemplate。

直接用hibernate事務有以下問題：
1。代碼完全綁定在Hibernate上。
2。自己控制事務難度比較大，不容易處理得好。

對第二點，很多人可能都不以為然，不就是一個beginTransaction和一個commit(), rollback()么？太門縫里看人了吧？

我就舉個sparkle同學的小弟寫的代碼吧：

try{
   PetBean pet = ;
   
   beginTransaction();
    ssn.delete();
    
    commit();
    petLog();
  }
  catch(Exception e){
     rollback();
     throw e;
  }

一個大的try-catch塊，在出現任何異常的時候都rollback。

我想會這么寫的人應該不在少數。同志們，革命不是請客吃飯那么簡單地。

問題在哪？

1。最嚴重的。try里面一旦有Error拋出，rollback()就不會被執行。sparkle同學說，出了Error我們就不管了。可以，反正出Error的幾率大概很小。所以你的軟件可以說“大多數情況是可以工作地”。

2。這塊代碼最終拋出Exception！如果外面直接套一個函數的話，簽名上就得寫"throws Exception"。這種函數就一個字：“害群之馬”。你讓調用者根本不知道會出什么異常，籠統地告訴人家“什么情況都可能發生”可不是負責任的態度。

3。這個代碼依賴于rollback()的特定實現。因為一旦exception是在beginTransaction()之前或者beginTransaction()時候拋出的，那么本來不應該調用rollback()的。調用 rollback()會出什么結果呢？如果rollback()不檢查當前是否在事務中，就壞菜了。而且，就算rollback()做這個檢查，嵌套事務 也會把一切搞亂。因為很有可能整塊代碼是處在另外一個大的事務中的。調用我們的代碼在我們拋出異常的時候，也許會選擇redo，或者修復一些東西，不見得總是選擇回 滾它那一層的事務的，不分青紅皂白地就rollback上層事務，這個代碼的健壯性真的很差。

看，小小一段代碼，bug和潛在問題如此之多。你還說自己寫事務控制簡單嗎？

真正健壯的，不對外界和調用者有多余的假設依賴的代碼，可以這樣寫：

 PetBean pet = ;
  
 beginTransaction();
 ok = false;
 try{
    ssn.delete();
    
    ok = true;
    commit();
   
    petLog();
  }
  finally{
     if(!ok)
        rollback();
  }

放棄try-catch，改用try-finally。這樣就不需要捕獲異常再拋出那么麻煩。然后用一個bool變量來告訴finally塊是否需要回滾。

這個代碼不難理解，但是如果處處都用這個代碼，也夠丑陋的。

既然已經用了spring，為什么不用spring的TransactionTemplate呢？用Spring TransactionTemplate（下面簡稱tt）的好處如下：
1。事務代碼不依賴hibernate，便于移植。
2。自動得到異常安全，健壯的事務處理。寫代碼的時候幾乎可以完全忘記事務的存在。

當然，sparkle同學有他的道理。使用spring tt需要實現TransactionCallback接口。而java的匿名類語法非常繁瑣。更可恨的是，匿名類只能引用定義成final的局部變量，這 樣在從tt里面往外傳遞返回值的時候就非常不方便。我們可能需要這么寫：

//xxx
  Object[] result = (Object[])tt.execute(new TransactionCallback() {
      public Object doInTransaction(TransactionStatus status) {
          Object obj1 = new Integer(resultOfUpdateOperation1());
          Object obj2 = resultOfUpdateOperation2();
          return new Objetct[]{obj1,obj2};
      }
  });
  System.out.println(((Integer)result[0]).intValue()+1);
  System.out.println(result[1]);

多么丑陋的result[0], result[1]呀。其它還有一些變體，比如每個結果用一個Object[]，或者定義一個通用的Ref類來支持"get()"和"set()"。

可是，這么多的方案，sparkle同學都不滿意。也是，這些方案都免不了類型不安全的down cast。而處理原始類型的結果還需要裝箱！


因為這些原因，我構思了一個簡單的spring tt的wrapper。一個Tx類。這個Tx類可以這么用：

//xxx
new Tx(){
  private result0;
  private String result1;
  protected void run(){
      result0 = resultOfUpdateOperation1();
      result1 = resultOfUpdateOperation2();
  }
  protected Object after(){
    System.out.println(result0+1);
    System.out.println(result1);
    return null;
  }
}.exec(tt);

通過把局部變量定義成Tx類的成員變量，我們繞過了downcast和原始類型裝箱拆箱的麻煩。通過把事務之后要執行的動作封裝在after()這個成員函數里面，我們可以方便地引用run()里面產生的結果。


下面看看Tx, TxBlock, TransactionBlockException這三個類的設計：

public abstract class TxBlock implements TransactionCallback{
  protected void before()
  throws Throwable{}

  protected abstract void run(TransactionStatus status);
  protected Object after()
  throws Throwable{
    return null;
  }
  protected void lastly(){}
  public final Object exec(TransactionTemplate tt){
    try{
      before();
      tt.execute(this);
      return after();
    }
    catch(RuntimeException e){
      throw e;
    }
    catch(Error e){
      throw e;
    }
    catch(Throwable e){
      throw new TransactionBlockException(e);
    }
    finally{
      lastly();
    }
  }
  public Object doInTransaction(TransactionStatus status){
    run(status);
    return null;
  }
}

public abstract class Tx extends TxBlock{
  protected abstract void run();
  protected void run(TransactionStatus status) {
    run();
  }
}

public class TransactionBlockException extends NestedRuntimeException {

  public TransactionBlockException(String arg0, Throwable arg1) {
    super(arg0, arg1);
  }

  public TransactionBlockException(String arg0) {
    super(arg0);
  }
  public TransactionBlockException(Throwable e){
    this("error in transaction block", e);
  }
}

所有的代碼都在這了（除了import）。
這個小工具除了after()，還支持before(), lastly()。before()在事務開始前運行。after()在事務結束后運行。lastly()保證不管是否出現異常都會被執行。

如此，一個薄薄的封裝，spring tt用起來庶幾不會讓sparkle再以頭撞墻了。