太極科技

Sublime多重選取

2024-01-29T09:49:00.002+08:00

「多重選取」是指在使用文字編輯器時，一種特殊的選取行為。不同一一般的選取動作，這種選取的區域並不連續。你可以同時整篇選取文章中相同的字，或是一個矩形的區塊。我大多數會在「重構」程時使用。記一些熱鍵對使用上來說會有很大的便利。以下是在sublime在多重選取操作上的一些熱鍵：

垂直選取(column select):
ctrl+alt+↑/↓
shift+右鍵
增加選取區: ctrl+shift+右鍵
減少選取區: alt+shift+右鍵
回上一步: ctrl+u
跳過下一步: ctrl+k
選擇下一個: ctrl+d
搜尋+選擇全部: alt+F3
跳到下一個搜尋: ctrl+F3

如果選過頭可以垂直選取後，再執行上一步。
ctrl+alt+↑/↓ 後+ ctrl+u
ctrl+d後+ctrl+u

alt+shift+←/→可以選字(subwords)。ctrl+shift+←/→也可以一次選一段，但切段點較不固定。

如何使用CURL來進行web service測試

2023-05-31T17:03:00.001+08:00

輸入參數

curl是linux上一個測試連線的工具。如果輸入參數很簡單，我們可以直接下參數指令進行測試：

$ curl -X POST -H "Content-Type: application/json" -d '{"status" : false, "name" : "Jack"}' "http://www.example.com/api/resources"

當輸入參數是XML或json格式時，可以將輸入內容存放在一個檔案中，再進行測試。

curl --header "content-type: text/soap+xml; charset=utf-8"--data @sample.xml http://$HOSTNAME:$PORT/$SOMEPATH

sample.xml

<?xml version='1.0' encoding='utf-8'?>
<soapenv:Envelope xmlns:soapenv="http://www.w3.org/2003/05/soap-envelope">
  <soapenv:Body>
    <ns0:some_operation xmlns:ns0="http://some_ns_uri"/>
  </soapenv:Body>
</soapenv:Envelope>

輸入帳密

若所存取網頁有使用 Basic Authentication認證，可以使用 `--user username:password` 來通過驗證：

$ curl -i --user secret:vary_secret http://www.example.com/api/resources

FixedOrderComparator簡介

2019-05-13T11:12:00.000+08:00

Apache commons collections 是一套專門針對Collection進行處理的一系列工具。其中提供了一些Comparactor，可以針對Collection來進行處理。這些Comparactor，大都放在org.apache.commons.collections.comparators package中。本篇文章主要針對其中的FixedOrderComparator進行demo:

以下是範例:

String[] data = new String[] { "GUEST", "NORMAL", "NORMAL", "PAID", "VIP", "VIP", "GUEST", "PAID" };
System.out.println(Arrays.toString(data));
Comparator<String> comparator = new FixedOrderComparator(new String[] { "PAID", "VIP", "NORMAL", "GUEST" });
Arrays.sort(data, comparator);
System.out.println(Arrays.toString(data));

[GUEST, NORMAL, NORMAL, PAID, VIP, VIP, GUEST, PAID]
[PAID, PAID, VIP, VIP, NORMAL, NORMAL, GUEST, GUEST]

如何在透過class指定相對路徑

2019-05-10T21:54:00.000+08:00

取得一個檔案有很多方法。一種是你知道絕對路徑。這是最簡單而且最穩定的方法。但很多時候，事情沒那麼簡單。因為你可能不知道系統在實際上線的時候，他機器的配置是怎樣。很多時候，你只知道他從工作目錄下的相對路徑時，這時該如何去指定這個檔案的路徑呢？

舉例來說，要讀取一個檔案，在開發的時候，可以知道這個檔案在我電的的本機的D槽，我可以輕而易舉的讀到他；可是在上線的時候，卻不知道這個檔案在那個槽(甚至搞不好上線的機器，根本就沒有"槽"，對，我說的就是linux)，只知道他的路徑是在：/db/crm.db下，這時候該怎麼辦呢？

解決方式

List<String> lists = IOUtils.readLines(this.getClass().getResourceAsStream("/db/crm.db"), "utf-8");

重點

主要是使用getClass().getResourceAsStream()。取得InputStream後需要做什麼不在討論範圍內。
需要使用 "/"開始。如果沒有"/"，則從目前的package開始找起。如果getClass()是com.foo那就是從src/com/foo開始找起；用另一種講法，就是跟目前class相同目錄。

如何使用 Struts 1.3如何接收json資料

2019-03-24T22:32:00.000+08:00

Struts是一個很舊的framework。不過在一些系統中，總會看到一些殘留的痕跡，硬是還在用這種framework。而新的技術仍在發展。一個例子就是web service。而當web service遇到Struts 1.3時，就很尷尬了。

目前的solution就是…自己parse。在這樣的solution下，基本上，不論那一個framework都可以使用這樣的解法。好吧，這完全跟struts沒有任何關係。這完全是標題殺手。換另一種標題就是：如何使用servlet解析json資料。不過以下要展示的重點，也不在json解析上，而是在如何處理httpRequest傳來的資料。注意，是資料，不是參數。也就是說，當web service即使以xml來傳遞資訊時，稍稍變化也依然可以應用。正確的標題應該是：如何使用servlet接收message body資料。至於什麼是message body，請參閱HTTP規格書。

以下是解析message body(外加轉為json)的範例程式碼：

public ActionForward applyResult(ActionMapping mapping,
 ActionForm form, HttpServletRequest req, HttpServletResponse res) {
        try {
            StringBuffer sb = new StringBuffer();
            String line = null;
            BufferedReader reader = req.getReader();
            while ((line = reader.readLine()) != null) {
                sb.append(line);
            }
            String sbStr = sb.toString();
            logger.debug("JSONStr:" + sbStr);
            JSONObject jsonObject = JSONObject.fromObject(sbStr);
            YOURBEAN resp = (YOURBEAN) JSONObject.toBean(jsonObject, YOURBEAN.class);
            logger.debug("JsonBean:"+resp);
            return mapping.findForward("result");
        } catch (Exception ex) {
    }

參考: java - HttpServletRequest get JSON POST data - Stack Overflow

Java中如何截取固定長的字串

2018-12-28T00:22:00.000+08:00

Java中截取字串的方法有很多，一般的情況下，我習慣使用Apache的StringUtils來處理。這是用來將字串進行縮寫的。不過StringUtils的字串截取，是根據char來截取。中文字算一個char、英文字算一個char。長度500的字串，就是500個字。範例如下：

StringUtils.abbreviate(str, maxWidth);

在某些資料庫中, 例如Oracle，可以開立欄位長度為單位為byte的欄位(varchar2(n byte))，這種欄位形不分中英文長度。當需要將適當長度的字串存入這樣的資料庫欄位時，截取長度的基準，就需要使用byte來計算。而中文字一般佔3byte，英文字是1 byte。有另外一種說法是中文字佔2byte，不過不管長度是多少，反正歐亞字元的編碼長度，就跟密碼一樣，我都搞不清。不過這並不影響我面接下來的內容。所以長度500的字串，在中英文夾雜的情況下，肯定不到500個字。解決的方法，主要是用Arrays.copyOf()這個method。

    private String abbreviate(String s) {
        byte[] sb = s.getBytes();
        final int max = 480;
        byte[] newsb = Arrays.copyOf(sb, max);
        return new String(newsb).trim();
    }

Maven從0開始

2018-12-19T11:16:00.000+08:00

我眼中的maven

Marvn是apache出的一個工具。他主要用來提供library的管理。他可以讓你在你的專案裡，快速的新增刪改library。這個特色，跟你手動新增、刪除library的差異在於，可以快速的處理library之間的dependence。所謂dependence就是我開發的程式中，需要用到A library，而這個A library會用到另一個B library V1版的程式，程式中用到的另一個C library會用到B library V2版的程式，這樣的一套接一套、一環接一環的關係。這時候系統架構師或是系統設計師，就必需先統計需要用到那些library，然後到各個官網去下載各種版本的library。有時候A library會用到B、C、D，C會用到D、E、F，這當中的情恨糾葛、悱惻纏綿是搞不清、理還亂。而maven可以讓你透過簡單的設定，讓你在架構的project、系統時，維護這些關係亂七八糟的library。

Apache 官網眼中的maven

當然maven提供的功能不只這樣，他可以直接包WAR檔、在deploy前進行測試、還有很多，我都搞不清楚的功能。某種程度上，他可以跟Apache早期出的另一套工具叫ant的進行比較。所謂的可以進行比較，意思是說他有很多相同，也有很多不同。基本上，他們的架構、理念，完全不一樣，但是功能上，有些重複。例如ant沒有提供library的管理、但ant與maven都有提供編譯、包WAR檔的功能。扯遠了，讓我們回到maven。

深入探討

讓一個從未接觸過maven的人，認知道maven是什麼，這樣的探討，大概就到這，不能再更多了。再多下去，就不是一個未接觸maven的人所可以接受的了。
如果你覺得你已經不再是一個「從未接觸過maven的人」接下來有關於maven的學習，就是maven的架構、設計理念、理論基礎、及如何使用了。這種東西，google是你最好的朋友，當然你也可以參考Maven 101，

如何使用jQuery達成動態查詢資料─以jQuery傳送Json給Struts2

2015-05-27T13:08:00.000+08:00

前言

我想大家都有需要在web系統上，使用動態查詢的功能。只要在查詢欄位上輸入查詢關鍵字，系統就直接顯示出查詢結果。企業需求在於：

不要再做任何的點擊動作，
整個頁面不用重新整理。

聽說最近jQuery很紅；也正好搭配新學習的Struts2，示範一下如何應用Struts2。僅管這標題下得有點像是論文題目，不過內容肯定沒那麼嚴謹。所以大家可以放輕鬆看一下。這篇主要的目的，雖然在講解如何達成動態資料查詢的這項企業需求，不過也會再稍微講解一下裡面的東西。一樣的；也都是分2階段：簡單的，和詳盡的─知其然，與知其所以然。

架構

基本上，需求很簡單，就是在頁面上的一個input欄位，輸入查詢關鍵字，畫面即時呈現所查詢的資料結果。

知其然

基本上是使用struts2、jquery 2個框架；不過struts2有再額外新增json-plgin

pom.xml

搭配Maven

<dependency>
    <groupId>taglibs</groupId>
    <artifactId>standard</artifactId>
    <version>1.1.2</version>
</dependency>
<dependency>
    <groupId>org.apache.struts</groupId>
    <artifactId>struts2-json-plugin</artifactId>
    <version>${struts2.version}</version>
</dependency>

strts.xml

<package name="taichitech" extends="struts-default, json-default" namespace="/">
    <action name="searchData" class="taichitech.jblog.struts2.SearchData" method="searchData">
        <result type="json" name="success">
        </result>
    </action>
</package>

其中一個重點在於需要繼自json-default package。

Java action

Struts2 action的部份

private String condition;

private Map<String, Object> returnData;

public String searchData() {
    logger.debug("Search condition: {}:", condition);
    returnData = new HashMap<String, Object>();

    char[] conditions = condition.toCharArray();
    StringBuffer reg = new StringBuffer();
    for (char c : conditions) {
        reg.append(".*");
        reg.append(c);
    }
    reg.append(".*");
    String regex = reg.toString();
    ArrayList<DataVo> vos = new ArrayList<DataVo>();
    for (DataVo dataVo : DATA_SET) {
        if (dataVo.getName().matches(regex) || dataVo.getUrl().matches(regex)) {
            vos.add(dataVo);
        }
    }
    returnData.put("SEARCH_RESULT", vos);
    returnData.put("COUNT", vos.size());
    return SUCCESS;
}
// Getters and setters of returnData、 condition.

上段程式碼，有用了一個vo；Vo有2個property、name與url。

public class DataVo {
    DataVo(String name, String url) {
        this.name = name;
        this.url = url;
    }
    private String name;
    private String url;
//Getters and setters
}

JSP script

JSP script 部份

<script language="javascript">
    var showdata = function() {
        $.ajax({
            url : "${pageContext.request.contextPath}/searchData.action",
            type : "POST",
            async : "false",
            data : {
                'condition' : $("#condition").val()
            },
            dataType : "json",
            success : function(jsonData) {
                var html = '';
                $.each(jsonData.returnData.SEARCH_RESULT, function(index, val){
                    html=html+val.url+'<br/>';
                });
                html+="Total: "+ jsonData.returnData.COUNT;
                $("#searchResult").html(html);
            }
        });
    };
</script>

JSP Html

JSP Html的部份，單純到不行…

<form>
    Search: <input id="condition" type="text" onkeyup="showdata(this);" />
    <div id="searchResult"></div>
</form>

結果

知其所以然

前面沒有提到的

基本上，我們的這套demo是使用struts2與jquery，上面沒有展示到的部份是，如何引用jQuery。我將程式碼補列列在下面。

在jsp中引用jQuery；jQuery的檔案放在/js目錄下。

<script type="text/javascript" src="${pageContext.request.contextPath}/js/jquery-1.10.2.js"></script>
<script type="text/javascript" src="${pageContext.request.contextPath}/js/jquery-ui-1.10.4.min.js"></script>

有關於pom.xml

這個展示使用了maven的方式。使用maven可以讓我只要copy paste簡單的幾個dependence，就可以自動匯入jar檔了！而且好處還在於可以省略許多不用的jar檔。在沒有maven的時候，從各官網下載下來的package，總包山包海，但我其實並沒有需要使用到那個framework所有的模組，可是在一開始學習的時候，時常搞不清楚那些jar檔該放、那些jar檔不該放。使用maven會幫你將這個問題處理掉。

在pom的部份，我並沒有撰寫struts-core的部份jar檔，但是我有指定說我要使用struts2-json。Maven 會自動的將所需要使用到的模組由repository下載下來。

你可以參考：

Maven 101：淺談Maven
Maven 官網

有關於struts.xml

這是很簡單的struts(struts2) 的宣告。全部的程式碼，與之前所列的沒有太大的差異，就請各位讀在在實作的時候，請自行補足缺少的部份。唯一個需要注意的重點是你的action必需要繼承json-default這個package。

圖片引用自網路。缺少的部份程式碼，請各位自行補充了。

有關於Java action

Action的部份，有2個重點。

其中一個是屬性的部份。

網頁的輸入會被存入condition這個property，回傳的資料以Map的型態儲存。主要查詢結果資料集，key值是SEARCH_RESULT；另外還有一個key為COUNT的資料，代表著查詢出來的結果筆數。如何取得這2個資訊，當然是依系統而有不同的實作，case by case。請注意，這裡的根結點，是action部份。你可以在struts.xml加上<param name="root">，額外指定根結點。

struts.xml

<action ... >
    <result type="json" name="success">
        <param name="root">returnData</param>
    </result>
</action>

直接呼叫Struts2Action，檢視回傳結果。 Struts2回傳的資料只是單純的文字格式

加上了<param name="root"> 回傳值與之前的不一樣。根結點由returnData開始

第2個重點是searchData() 這個method。

searchData()是主要的搜尋程式邏輯所在。他依據使用者所輸入字元，對資料集進行搜尋，使用者每次在查詢輸入欄位每敲一個字，就會對server做一次request，可想而之，其實這種企業功能是很秏資源的。當然這部份是可以再加強的部份，不過這已經超過本篇範籌了。

搜尋的部份，使用了正規表示的功能。

這裡分解使用者的輸入，使用了迴圈，產生表示式，並對資料加以比對。比對的部份，包含了DataVo的name與url2個屬性。在這樣的程式下，你可以輸入ggc查詢到googole.com，只要name或url符合都會被篩選出來。當然這部份也是case by case。

JSP script 的部份

JavaScript的部份，使用了jQuery。 Ajax 的部份，是使用了ajax()這支method。

jQuery.ajax( url [, settings ] )

延伸參考 jQuery 官方 API:

jQuery ajax() API

特別強調以下幾點：

data：需要傳回server的參數。必需為VO、String、或是Array。 VO是key-value的型態。預設會以GET的方式加在URL後。
dataType：預計從server要回傳的資料型態。你可以有xml, json, script, or html這些選項。如果不指定的話，jQuery會自己猜…，這種不確定的東西，還是指定比較恰當。
type：也可以用method。表jQuery提交資料的方式。預設是GET。以資安來說，太危險了，請一定要用POST。
async：說明request以同步或非同步的方式傳送給server。預設是非同步。非同步的好處，雖然看似可以加快反應速度，但是也同時表示，在資料還沒有完全傳送完畢前，後端就可以開始動作；如果開始處理還沒傳送過來的資料有可能就會出事。
success：像success: function(){};裡的function 稱為callback function。表示jQuery在表示success後會繼處理function裡面的部分。
jsonData：雖然以struts2 的Action回傳的結果，看似是json型態，可是在jQuery 1.5以後，jsonData卻被封裝成名為jqXHR(jQuery自己的XmlHttpRequest)的物件。
jQuery並不認回資料只是單純的文字檔

範例上直接使用jsonData.returnData.SEARCH_RESULT取得集合，將資料傳給接下來的jQuery的each()。
each()有2種，參數是array或是object。如果是object ，則必需是key-value的格式。。詳細格式是這樣：

jQuery.each( array, callback )
callback
Type: Function( Integer indexInArray, Object value )

jQuery.each( object, callback )
callback
Type: Function( String propertyName, Object valueOfProperty )

你還可以參考： jQuery Each API doc

結語

這裡展現了一個完整的實作，可以進行動態查詢。所使用的技術，包含jQuery、Json、Struts2、Maven。文中你可以看到struts2使用result type='jason'的回傳結果。文中也稍微介紹了jQuery ajax()與each()2支api的用法。

你的第一隻Java程式─Hello World

2015-05-19T10:30:00.000+08:00

圖片引用自bestmag.net

一開始學習語言，我的慣例都會先給hello world!! 可惜在Hello world之前，還是有一些事必需要做，也有一些東西必需要先了解…

安裝

Java 下載

先別急著想打開文字編輯器，copy 一份程式碼，然後paste上去。理由除了你必需要先了解你在copy 些啥鬼之外，你還必需先安裝Java，不然你paste完後，你會不知道如何去執行他。不過題外話，在初學階段，我還是強烈建議你純手動敲一次程式碼。

你必需先到Java 官網去下載Jdk。目前(2015/5) Java的維護者是Oracle；基本上你在網路上打了關鍵字去搜尋一下，應該就會對了。我先列出連結，但很可能在未來不久的日子裡，這個連結會失效。

Oracle java

下載版本有幾點需要注意：

符合你的作業系統
Java SE。注意，不是Java EE。
JDK。注意，不是JRE。

如果你不清楚Java SE與Java EE的差別，或是JDK與JRE的差別，你可以參考Java 101-Overview。

下載下來之後，就是無腦安裝的「下一步」、「下一步」…。(Windows 限定)

僅管是無腦安裝，我還是很建議你，仔細看看你安裝了些啥鬼。或許你現在還不知道你道底安裝了些啥，但在往後的日子裡，你將會學到這些東西。

環境設定

安裝完後，你必需再設定3個環境變數。

JAVA_HOME。指到你剛安裝的Jave的目錄。
CALSSPATH。用「;」設定2個值：1個是你的工作目錄─「.」；1個是JAVA_HOME\lib裡的tools.jar。
PATH；指向JAVA_HOME裡的bin目錄。

環境設定：這是尛？

JAVA_HOME，是說明你目前的工作環境下，你正在執行那一個Java。這表示，你可以在同一一台機器下，安裝多個JDK與JRE。

CLASSPATH；是告訴Java─其實是告訴JVM─你可以引用的其他的模組或函式庫。因為我還沒有介紹什麼是library，所以就先用「模組」、「函式庫」這樣的翻譯名詞…。好吧，library就是「函式庫」。如果你還對什麼是「函式庫」或是「模組」還很模糊，沒關係，就先暫時打住，在往後的日子裡，你終究會體會到。現在還只是hello world... 。

tools.jar這個函式，就是在你編譯程式時，會用到的一個函式庫。原則上Java的函式庫，副檔名都是用.jar。 其實這只是一個簡單的壓縮檔，沒什麼特殊的編碼內容。你可以使用WinRAR或是WinZip，或是任何一套可以解壓縮的程式，來檢視其內容。

PATH；這是告訴作業系統你的程式要到那些路徑下去搜尋java.exe這個執行檔。

可以Hello World了嗎？

還不行。到目前為止，你大致完成一個HelloWorld的前置準備。接下來，你還差一個文字編輯器。

你可以使用任意一款文字編輯器，但是要注意一點，就是儲存格式需要可以儲存成UTF-8 without BOM 或是編碼格式。

BOM是…一種東西；雖然會越帶越多，不過為了滿足一部分讀者的好奇心，還是要簡單帶過一下，更多的就需要再另外開篇幅了。 BOM是Byte-Order Mark，是編輯軟體在存檔時，在檔案前面加的一個註記，說明這檔案的詳細格式。 UTF-8 with BOM是微軟專用的格式。 Java 一般開發不採用這種；所以一般使用without BOM。

我要Hello World~~

開始Hello World

好吧!! 我們真的可以開始撰寫一個Hello World了。

請找一個乾淨的目錄。這個目錄會是你的工作目錄。我的demo會是這樣：
```
d:\Temps\JavaTutoDemo
```
在這裡面建一個目錄。
```
d:\Temps\JavaTutoDemo\bookstore
```
請打開你剛準備的文字篇輯器，開始敲程式碼了。產生一個名為BookStore.java的檔案。敲入以下程式碼；然後以UTF-8 without BOM的格式存到bookstore目錄下。
```
package bookstore;
public class BookStore{
public static void main(String[] args){
 System.out.println("Hello Java");
 }
}
```

使用命令列模式，到工作本位目錄(JavaTutoDemo)，執行以下命令：

d:\Temps\JavaTutoDemo>javac -encoding utf-8 bookstore\BookStore.java
d:\Temps\JavaTutoDemo>java bookstore.BookStore
Hello Java

學而不知則罔

繼之前的三個小之後，還是需要講解一下你剛才到底打了些什麼東西。雖然我並不是很喜歡古文的那些之乎則也，也覺得那些早該作古的東西，十之八九不應該還存在在這個世界，不過有時候，還真的必須佩服那些古人，可以在那麼久遠的年代，就發現那些即使是在現在，也還應該存在於這個世界的那些十之一二的部份。

圖片引用自http://www.23yy.com

檔案BookStore.java的第一行，是package的宣告。所謂的package，你可以將他視為一群程式。將相同性質的程式放在一塊，就是一個package。 Package名稱必需跟目錄名稱相同。
第二是行宣告一個類別。有關於類別，未來還會再談到更多。現在，你就當類別…就是一個類別。 class是關鍵字；說明我正在宣告一個類別。類別名稱必需跟檔案名稱相同
第三行，是宣告一個函式。以Java的專用術語，我們叫method。C、其他的程式語言、或是計算機概論中，稱為函式或叫function；在目前你可以先將他視為是相同的東西，不過在物件導向中，這是有很大的差別。
static 是關鍵字，有著特殊的意思，他代表著這個method應該是由class來執行。我在之後的文章裡會再詳細提到這點。
String 在這裡是一個種資料型別。在Java裡面，他當然是一種class，而這個class的名稱叫做String。不過我們在這裡，就先把他視為是一個字串吧！就好像 "This is a string" 這樣的一個字串。
[] 是表示陣列，所以String[]就是字串陣列的意思。
所以，這一行的意思是說，我宣告一個static的method，名字叫做main，他有1個輸入參數，參數名稱叫args，型態是String[]。
第四行執行的動作，就是列印出一個"Hello Java"字串。
在第4動，執行了2個命令。第一個命令，是產生執行檔。 javac的c 是Compilier的意思。你可以看bookstore目錄裡，多了一個BookStore.class的檔案。Java在執行時就是執行這個檔案。
第四動的第二個令命則是直接執行這個執行檔。注意，這裡不能加class副檔名。從作業系統執行的method，永遠是static method，而且名稱永遠叫main。這也就是為什麼我們可以直接由作業系統直接執行這個Hello world的原因。

前面我沒有提到的

前面我沒有提到的是：

Java的世界裡是區分大小寫的。如果你在練習的當中有發生任何錯誤，確定一下是不是大小寫有打錯…。
開發慣例上，package的名稱一律都是小寫。Class是以大寫開頭的Camel style。例如BookStore、HelloWorld。Method以小寫開的的Camel style，例如buyBook、takeOrder或是order。

結語

到目前為止，你已經做出一個沒啥用處Hello Java程式。僅管程式本身沒啥用處，但是裡面所隱藏的知識不少。你應該知這了CLASSPATH、PATH、JAVA_HOME的用處、還有建立一個java程式的文法、結構、與宣告方式。如果想學好一門程式語言，最好的方法，還是要實際下去演練一遍。

物件的具現─如何將物件存成檔案

2015-05-13T14:43:00.000+08:00

Java裡有一種物件叫java.io.Serializable，是可以讓物件在Serialize後在不同的儲存體中傳遞。中文譯做序列化。今天講講怎麼麼將物件存到硬碟這個儲存體…。

假設我有一個物件是這樣：他是一個Serializable的物件。裡面有一個Collection(datas)，可以用來存放Serializable的物件。

public class FileDatas implements Serializable {
    private static final long serialVersionUID = 8048736089512288707L;
    public Collection<Serializable> datas;
    public FileDatas() {
        datas = new HashSet<Serializable>();
    }
    public Collection<Serializable> getDatas() {
        return datas;
    }
}

與另外一個Serializable物件Book：

public class Book implements Serializable {
    private static final long serialVersionUID = -4088035671812463272L;
    private String isbn;
    private String author;
    private String name;
    public Book() {
    }
    // Other gets and setters.
    @Override
    public String toString() {
        return "Book [name=" + name + "]";
    }
}

於是我要將Book這個物件存為實體檔案與取得的方式，大概是這樣：

package taichitech.common.db;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.Serializable;
import java.util.Collection;

import org.apache.commons.lang3.SerializationUtils;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class FileDatasTest {
    Logger logger = LoggerFactory.getLogger(getClass());

    @Test
    public void testSetDatas() {
        try (FileOutputStream fout = new FileOutputStream(filePath);) {
            FileDatas fd = new FileDatas();
            Collection<Serializable> datas = fd.getDatas();
            datas.add(newExampleBook("994-443-989", "Tom Edsion", "How to Generate Java Class?"));
            datas.add(newExampleBook("907-43-169", "Willion Smith", "Eclipse Pro, 2Ed"));
            datas.add(newExampleBook("659-771-01", "Water 13", "如何銷售你自己"));
            logger.debug("Books {}", datas);
            SerializationUtils.serialize(fd, fout);
        } catch (Exception e) {
            logger.error("Fial", e);
        }
    }

    private Book newExampleBook(String isbn, String author, String name) {
        Book b = new Book();
        b.setAuthor(author);
        b.setIsbn(isbn);
        b.setName(name);
        return b;
    }

    private final String filePath = ".filedatas.ser";

    @Test
    public void testGetDatas() {
        try (FileInputStream fin = new FileInputStream(filePath);) {
            FileDatas fd = SerializationUtils.deserialize(fin);
            logger.debug("Books {}", fd.getDatas());
        } catch (Exception e) {
            logger.error("Fial", e);
        }
    }
}

testGetDatas示範了如何將物件存成檔案，而testGetDatas示範如何將檔案再轉回物件。

這裡我主要是使用Apache commons-lang3的SerializationUtils這個物件。其實deserialize()或serialize()裡面就是將Object 轉成ObjectInputStream或ObjectOutputStream。

延申閱讀：

你可以參考如何轉Serializable物件轉成byte[]。

毫無疑問的，打算要存成檔案的物件，都必需要是Serialiazble，所以Collection裡的物件，或是相關property的型別，都必需要是Serializable。

2個UT測試的執行結果如下：

10:38:11.569 [main] DEBUG t.c.db.FileDatasTest[24]-Books [Book [name=Eclipse Pro, 2Ed], Book [name=How to Generate Java Class?], Book [name=如何銷售你自己]]

11:31:45.541 [main] DEBUG t.c.db.FileDatasTest[45]-Books [Book [name=How to Generate Java Class?], Book [name=如何銷售你自己], Book [name=Eclipse Pro, 2Ed]]

儲存的檔案，用文字篇輯器打開會是這個樣子：

這個檔案存了3個Book 物件與一個FileDatas物件

同場加印

我在unit test中產生Book物件的方式就是Factory Method的應用。

延申閱讀：

Design Pattern 102: Factory Method

Java 101-Overview

2015-05-13T01:31:00.000+08:00

基本上我是寫Java 的。就先對Java來做個介紹。

其實這個題目是很有挑戰性。挑戰在於需要在很短的篇幅、時間為我很熟悉的東西做介紹。

前言

因為篇幅有限，但是又不能跳過，所以就講幾個重點吧！！

Java 是昇陽電腦公司的詹姆斯·高斯林等人於1990開發的一種物件導向語言。他屬於直譯式語言。具有跨平台的特色。

(我真的不適合當行銷人員呀，真的不會寫文案…)

模組

接下來是重點了。

Java的版本，分為3個版本：Java SE(Java Standard Edition)、Java EE(Java Enterprise Edition)、Java ME(Java Mobile Edition)。 SE是所有基礎中的基礎，EE是專為企業所開發出來的架構，ME是為移動裝置所開發出來的架構。執行上，Java 分為JRE(Java Run time Environment)與JDK(Java Develop took Kit)。JDK包含了許許多多的開發套件；所有開發出來的程式，都必需在JRE上執行。就某種角度來看Java雖然宣稱跨平台，但其實不是；因為他只能在JRE這個平台上面執行。真正跨平台的是JRE。

以下我們先針對Java SE 與Java EE這兩塊來做介紹。

Java SE

Java SE的模組

Java SE 的模組就是以上這些。眼花撩亂對吧，沒關係，我先提出幾個部份出來。這幾個部份是非常、非常、非常、常用到(很重要，所以要講3次)，未來堂學習的時候，必需要特別熟悉。

Lang and util
Collections
Input/Output
JDBC

當然有很多是時常在用，可是你不知道你在用的東西。這些東西在「很」未來還是需要知道，不過現在，就先在此打住吧！

Java EE

Java EE 其實我沒法介紹太多，因為有許多我並沒有接觸過。他基本上是由一系列的規格所兜出來的。在這裡將所有的規格名詞一口氣打上來，也同樣的會讓人眼花撩亂，而且意義也不太大。我講幾個重要的名詞吧！不過這些名詞並不是Java EE 的規格名稱，而是在未來在學習Java EE時所必需要知道的。

詞	說明
Servlet	在網際網上執行的Java 程式。也許這樣的定義不是很正確，但我想初學者先這樣看待servlet就好。
Web Container	一個可以執行Servlet的環境
EJB Container	Web Container的進階版。除了可以執行一般的servlet，還可以架設web service，設置一堆Java bean、Pool、有的沒的。
JSP	Java 版的ASP。如果你不知道什麼是ASP，那你就把他當做是網頁的頁面。同樣的，這樣定義也不盡然正確，不過也是先這樣看待就好
EJB	Enterprise Java Bean，運行在EJB Container上的一些Java bean。

Bean

有個名詞在上面提到很多次，不過到目前為止，我還沒有對他做介紹，那就是Bean。 Bean是Java中，有著特殊定義的一種類別。官方定義如下：

有一個公有的無參建構元。
屬性可以通過get、set、is（可以替代get，用在布爾型屬性上）方法或遵循特定命名規範的其他方法訪問。
可序列化。

這裡是一個bean的範例。

public class FaceBean {
    private int mMouthWidth = 90;

    public FaceBean(){};

    public int getMouthWidth() {
        return mMouthWidth;
    }

    public void setMouthWidth(int mw) {
        mMouthWidth = mw;
    }
}

結語

這篇文章大概介紹了一下Java 的生態，讓大家稍微了解一下什麼是Java。

Struts1昇級有問題？如何將.do導頁到.action

2015-05-10T01:15:00.000+08:00

緣起

Struts 是一個老牌的Java web framework。有多老，老到Struts1 已經停止維護了。 Struts2看似是Struts1的延伸，不過Struts2是不向下相容於Struts1。所謂的不向下相容，並不是指Struts1與Struts2 framework不能同時存在於一個web application裡面，而是使用struts1寫的程式，沒有辦法僅僅拿掉struts1的jar檔、加上struts2的jar檔，web.xml設一設就可以用了。那些原本struts1寫的程式，還是需要進行相當程度的改寫。除了將struts1的程式改為使用struts2的架構外，許許多多的連結也需要換掉。因為struts1預設副檔名是使用.do，struts2的副檔名是使用.action，在昇級的時候，如果不是一次到位，就會導致系統裡面，Struts1的jar檔與Struts2的jar檔同時存在，.do的連結指向struts1的功能，.action的連結就會使用struts2的功能。然而在一個已經上線的系統上，也似乎必需得這麼做，讓系統一支作業一支作業的昇級...

現在問題來了。如果一支作業已經由struts1昇級到struts2，但是我們無法確認外部系統對內的所有的.do連結，是否已經全部換成.action。一個折衷的辦法，就是讓.do的連結再forward到.action。這就是我們今天要講的，如何讓指向struts1的.do連結導到struts2的.action。

請注意，以下方法適用於servlet 2.4以上 。

如何做？

Struts2 是使用filter的方式來install的，所以我們唯一要做的，只要在web.xml的地方增加forward dispatcher；struts1的action則直接使用config的方式forward到struts2的連結，就可以讓struts2在forward時觸發。

struts-config.xml.

<action path="/struts1moreaction" forward="/struts2action.action" />

strus.xml

<package name="taichitech" extends="struts-default" namespace="/" >
    <action name="struts2action" class="taichitech.struts1to2.Struts2Action" method="execute">
        <result name="success">/submitted2.jsp</result>
    </action>
</package>

web.xml

<filter-mapping>
    <filter-name>struts2</filter-name>
    <url-pattern>*.action</url-pattern>
    <dispatcher>FORWARD</dispatcher>
    <dispatcher>REQUEST</dispatcher>
</filter-mapping>

我剛看了小小小？

如果看不懂到目前為止的程式碼，接下來我會有更詳細的描述。

基本上，一個系統的架設可以有很多種方法。我這裡demo的是使用Maven的方法建立的。當然，你也可以自己直接手動將jar檔放入相關的位置。

Dependency

Struts1 與Struts2所使相關的lib檔，可以透過Maven直接設定取得。 Pom.xml的設定是這樣的：

<dependency>
    <groupId>org.apache.struts</groupId>
    <artifactId>struts2-core</artifactId>
    <version>2.3.16.3</version>
</dependency>
<dependency>
    <groupId>org.apache.struts</groupId>
    <artifactId>struts-core</artifactId>
    <version>1.3.10</version>
</dependency>
<dependency>
    <groupId>org.apache.struts</groupId>
    <artifactId>struts-extras</artifactId>
    <version>1.3.10</version>
</dependency>
<dependency>
    <groupId>org.apache.struts</groupId>
    <artifactId>struts-taglib</artifactId>
    <version>1.3.10</version>
</dependency>

Web.xml

Struts framework(不管是1或2)都有龐大的功能，與相對應的組態。這裡展示最基本的設定。這個web.xml同時設定了 Struts1與Struts2。其實Struts1與Struts2是可以同時放在相同一個app裡的。

web.xml

<web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
          http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    version="2.5">
    <display-name>Servlet 2.5 Web Application</display-name>
    <filter>
    <filter-name>struts2</filter-name>
    <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>struts2</filter-name>
    <url-pattern>*.action</url-pattern>
<!-- Here is point -->
    <dispatcher>FORWARD</dispatcher>
    <dispatcher>REQUEST</dispatcher>
  </filter-mapping>
  <servlet>
    <servlet-name>action</servlet-name>
    <servlet-class>org.apache.struts.action.ActionServlet
         </servlet-class>
    <init-param>
      <param-name>config</param-name>
      <param-value>/WEB-INF/classes/struts-config.xml</param-value>
    </init-param>
  </servlet>
  <servlet-mapping>
    <servlet-name>action</servlet-name>
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>
</web-app>

請注意struts2的那個filter-mapping。在一般的教學中，struts2的設定檔都不會告訴你需要使用<dispatcher>。這是servlet 2.4以後的規格。預設是REQUEST所以在一般的情況下，是不需要額外設定。不過我們這裡的策略是讓struts1的url link(也就是*.do) 經過struts1 framework後再forward到 struts2 framework，所以需要再額外指定<dispatcher>FORWARD</dispatcher>讓struts2的filter可以在forward的時候被觸發。

struts-config.xml

這是struts1的預設設定檔。它長的像是這個樣子。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.2//EN" "http://struts.apache.org/dtds/struts-config_1_2.dtd">
<struts-config>
    <action-mappings>
        <action path="/struts1action" type="taichitech.struts1to2.Struts1Action"
            parameter="method" scope="request">
            <forward name="success" path="/struts2action.action" />
        </action>
        <action path="/struts1moreaction" forward="/struts2action.action" />
    </action-mappings>
</struts-config>

我示範了2種手法。第一種，仍然經過struts1 action。不過success這個ActionForward的path是指向struts2的url。看，url的後綴是.action。

第2個更省事，連struts1的class也不用，直接forward到struts2。 Action這個tag，什麼也沒做，甚至連class也不指定了，直接forward 到struts2的url。

struts.xml

Struts2的設定檔，預設檔名是struts.xml。這與一般教學是一樣的，沒什麼特別的差異。最後會導到/submitted2.jsp。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
    "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
    <constant name="struts.devMode" value="false" />
    <constant name="struts.ui.theme" value="simple" />
    <package name="taichitech" extends="struts-default" namespace="/" >
        <action name="struts2action" class="taichitech.struts1to2.Struts2Action" method="execute">
            <result name="success">/submitted2.jsp</result>
        </action>
    </package>      
</struts>

Action

Struts1

Struts1 的action 範例：

public class Struts1Action extends DispatchAction {

    public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request,
            HttpServletResponse response) throws Exception {
        Logger logger = LoggerFactory.getLogger(getClass());
        logger.debug("Execute Struts1Action.execute");
        return mapping.findForward("success");

    }
}

Struts2

Struts2 action的範例：

public class Struts2Action extends BaseAction {
    public String execute() {
        Logger logger = LoggerFactory.getLogger(getClass());
        logger.debug("Execute Struts2Action.execute");
        return Action.SUCCESS;
    }
}

index.jsp

<body>
    <a href="${pageContext.request.contextPath}/struts1action.do">Here
        is an .do link-</a> <br/>
    <a href="${pageContext.request.contextPath}/struts1moreaction.do">Here
        is an more .do link-</a>
</body>

submitted2.jsp

<body>A page that submitted!!
</body>

由於是採用forward的方式，url還是.do。

結論

在系統改版時，可以一次到位，將所有的struts1的action重新改成struts2、struts1的jar檔可以一次被抽換掉，當然是最好。如果不行的話，這樣的一個折衷的保險措施是必需要的。當然一個系統的昇版並不是那麼簡單，還有許多的的部份，例如action form如何轉換、validation、action error、action message如何修改，這些都是考驗著我們的智慧。

Design Pattern 介紹：Memento

2015-05-06T17:58:00.000+08:00

Memento design pattern的class diagram。圖片取自Wiki

Memento 這個pattern的使用範圍很明確，就是當你有rollback、undo這類需求的時候的時候，都可以使用。我們透個一個情境來介紹一下memento這個pattern 。

Ok，情境是這樣的…。

你的需求是一個交易(Transaction)。使用者買東西時，會從帳號(Account)裡扣錢，每次扣1000元。我今天有一段很無聊(？)的程式(demoMemento)，扣了2次錢之後，使用者硬是要rollback回去，當交易沒發生過。所以你必需將帳號的狀態設會原本扣2次錢之前的狀態。`

Memento design pattern情境的 class diagram

以下是RunDp.demoMemento()的程式。這一段是主程式。

package taichitech.jblog.dp;

public class RunDp {
    Logger logger = LoggerFactory.getLogger(getClass());

    public RunDp() {

    public static void main(String[] args) {
        RunDp rd = new RunDp();
        rd.demoMemento();
    }

    public void demoMemento() {
        AccountDao accountDao = new AccountDao();
        String accountId = "99004-PETER-22-114";
        int amount = -10000;
        //Get account from Dao and deduct amount x 2. 
        Account account = accountDao.findAccount(accountId);
        //Before deduct, we create a memento.
        account.createMemnto();
        account.setBalance(account.getBalance() + amount);
        logger.debug("Account info-1:{}", account);
        account.createMemnto();
        account.setBalance(account.getBalance() + amount);
        logger.debug("Account info-2:{}", account);
        account.restoreMemnto(2);
        logger.debug("Rollbacked Account info:{}", account);
    }
}

main那些什麼的都不是我們要講的重點；demoMemento()才是主程式的重點。

程式一開始產生了一個AccountDao，超顧名思義的，就是可以透過一個accountId取得一個Account物件。

Account物件可以做3件事：1. 建立memento(createMemnto())，2. 扣款(Account.setBalane())，3. 回復狀態(restoreMemnto())。

RunDp取得Account後，首先建立了一個memento、然後扣款(-10000)、印出訊息；這樣的動作一共做了2次。然後使用者~~閒東西太貴~~又想取消交易，於是我們只好將狀態回到2次交易前的樣子(restoreMemnto(2))。

接下來我們看一下Account，這部份才是我們要提的memento重點：

package taichitech.jblog.dp.vo;

public class Account {

    @Override
    public String toString() {
        return "Account [accountId=" + accountId + ", balance=" + balance + ", snapshot=" + snapshots + "]";
    }

    private String accountId;

    private int balance;

//...Other getter and setter of properties.

    private ArrayList<Memento> snapshots = new ArrayList<>();

    private class Memento {
        int balance;

        public int getBalance() {
            return balance;
        }

        public void setBalance(int balance) {
            this.balance = balance;
        }
        @Override
        public String toString() {
            return "Memento [balance=" + balance + "]";
        }
    }

    public void createMemnto() {
        Memento memento = new Memento();
        memento.setBalance(this.balance);
        snapshots.add(memento);
    }

    /** @param undoTimes Times of undo. */
    public void restoreMemnto(int undoTimes) {
        undoTimes = (snapshots.size() < undoTimes ? snapshots.size() : undoTimes);
        for (int i = 0; i < undoTimes; i++) {
            int lastIndex = snapshots.size() - 1;
            this.balance = snapshots.get(lastIndex).getBalance();
            snapshots.remove(lastIndex);
        }
    }
`}

Account除了記錄餘額外，裡面還有一個snapshots的property。他是一個Mement class 的集合(ArrayList)，這是用來記錄每次的狀態，每createMemnto()一次，就會產生一個Memento物件加到集合裡。

Memento class是一個innter class。使用innter class主要是基於權限的關係。RunDp或是其他的Programmer、維運人員，可以完全不用知道裡面的狀況。這樣除了可以避免不小心改到不相關的程式碼外，也可以避免混淆視聽。當然，你也可以把Memento開放出來，讓RunDp、或是其他人員進行其他的操作。這裡指的其他不應該包含會影響到Account原本狀態的操作。有關於Account狀態的一些操作，應該將權限綁成全部由Account來進行操作。

另外一個restoreMemnto() 是將Account的狀態回復。參數是回復次數，可以回復前undoTimes次。裡面的迴圈，會依次取得最後一次Memento的物件，然後將資料回設給Account。回設後會將該物件由snapshots中拿掉。當然，以design pattern來說，裡面的那些個回復、怎麼的回復，也不是重點；重點是memento design pattern 通常會有個method，以供回復狀態。

在實作上，你可以直接指定ArrayList.get(index)，取得特定的Memento，然後移除該index後的所有元素，這樣看似會比較有效率一些；而要不要移除元素，這也完全看需求，你也可以保留做為歷史追蹤。

這裡是執行結果：

868 [main] DEBUG t.jblog.dp.RunDp[37]-Account info-1:Account [accountId=99004-PETER-22-114, balance=690000, snapshot=[Memento [balance=700000]]]
869 [main] DEBUG t.jblog.dp.RunDp[40]-Account info-2:Account [accountId=99004-PETER-22-114, balance=680000, snapshot=[Memento [balance=700000], Memento [balance=690000]]]
869 [main] DEBUG t.jblog.dp.RunDp[42]-Rollbacked Account info:Account [accountId=99004-PETER-22-114, balance=700000, snapshot=[]]

請注意，這裡的回復是指「回到原本的狀態」不是「將錢還回去」。這2種描述在實作上有很大的差別。第一種是像demo程式，直接將狀態「設」回去。第2種則是你必需要記錄每次所扣的錢，然後一次一次「加」回去。也就是第2種描述，你必記錄的不見得是變更前的「狀態」，而是每次變更的「異動」，例如-10000。

限制

一個最明顯的問題，當然是記憶體的問題。每mementdo一次，就是一個記憶體；可以備份多少次、要備份那些狀態，當然要量「機」而為。
如果你將Memento class 開放給Account以外的類別使用，需要注意開放的範圍；不可以讓開放的操作影響到Account的狀態。像Memento.getBalance()與Memento.seBalance()就應該只能由Account來呼叫，不能由RunDp呼叫。

結語

在原著上，Memento 這個pattern有3個class：Caretaker、Originator、Memento；對應到我們的demo code，分別是RunDp、Account、Account$Memento(這是一個innter class)。 Caretaker操作Originator的方法，以決定什麼時候需要memento。 Memento儲存Originator的狀態。 Caretaker可以操作Memento，不過不應該操作Orignator狀態的相關資訊；Originator狀態的變更，只應交由Originator來操作。 Memento在儲存Originator狀態時，可以有不同的儲存方式與應用方式，例如備份狀態，或是備份差異，當然，備份時也需要考慮到resource是否足夠或是resource 的釋放。

個人覺得使用機會是比factory method、facade 或是其他的pattern要來得小的多。儘管如此，當有用上的時候，他還是很有用。

Design Patter 103：輪流取得每個物件─Iterator簡介

2015-03-31T02:11:00.000+08:00

上一篇介紹了Simple factor pattern，今天來介紹一下Iterator。

Iterator，中譯迭代。簡單來說，Iterator 就是對集合裡的每個原素進行處理。

如果你在演算法裡有看到「對XX裡的每個YY…」，那你通常都會用到這個pattern。

for each y in x
    do blablabla
end for;

Iterator pattern 是對集合裡的每個原素(element)進行處理，因此他的構成的成份，第一個就是「集合」這個元件。(好像是廢話呢…) 第二個元件，是通常會有個指標，來記錄目前處理到那一個原素；第三個元件是需要處理一些事。程式在處理完那些事後，就將指標移往下一個原素。第四個，就是這一段程式碼裡，通常會需要有個判斷式，來判斷是不是所有有東西都已經處理過。

接下來看一下實際例子。

假設我一個書櫃(BookShelf)，有書櫃就有書(BookVo)…這次書是我們要講的重點了。

於是程式碼Iterator interface會是像這個樣子：

public interface Iterator<E> {
    boolean hasNext();
    E next();
}

由於我們要依次處理的是書(BookVo)；所以實作這個interface的程式碼會是這個樣子。

private class BookVoIterator implements Iterator<BookVo> {

        private int index = -1;

        @Override
        public boolean hasNext() {
            return index < size - 1;
        }

        @Override
        public BookVo next() {
            index++;
            return bookVos[index];
        }
    }

next()是裡含了二個元件：第一個是指標(這不是C語言中的指標)的移動。第二個是「處理」；它除了在每次iterate時會將指標移到下一個原素之外，還做了一個動作：生出BookVo，並加以回傳。

hasNext()是第四個元件，它負責判斷是否還有下一個需要處理的原素，少了這元件，就會淪落成無窮迴圈(雖然有時需要這麼做…)。

那第一個元件呢？再下面。

public class BookShelf implements Iterable<BookVo> {

    private BookVo[] bookVos;

    public BookVo findBook(String bookName) {
        for (Iterator<BookVo> it = iterator(); it.hasNext();) {
            BookVo bookVo = it.next();
            if (bookVo.getName().equals(bookName)) {
                return bookVo;
            }
        }
        return null;
    }
}

我們之前提到第一個元件，就是集合。在這個例子裡，書的集合就是書櫃(BookShelf)。先暫時別管Iteratorable這個interface；這個interface現在還不是重點。重要的是iterator的使用方式；主要client端method(就是使用端、呼叫的程式)是findBook。顧名思義，就是從書名找書；怎麼找？一本一本找。 對書櫃裡的每一本書進行比對，直找到書名相同的書為止。有注意到嗎？「對XX裡的每個YY…」，我又用到這樣的描述了…。

總而言之Iterator的class diagram。

要怎麼用？

Java 1.5 有提供了enhance for loop的語法。我還蠻常用這個。主要是因為我認為電腦就是該執行重覆的工作；反正就是有一堆工作叫電腦去做，讓電腦針對所有工作任務裡的每一個工作(對XX裡的每個YY…)，一項一項執行…。在for each裡的集合，必需要實作Iterable interface。因此，上面的findBook可改寫borrowBook：

public BookVo borrowBook(String bookName) {
    ShelfFactory boFactory = context.getBean(ShelfFactory.class);
    BookShelf bookShelf = boFactory.getBookShelf("POMO");
    for (BookVo book : bookShelf) {
        if(book.getName().equals(bookName)){
            return book;
        }
    }
    return null;
}

可以看到for (BookVo book : bookShelf)的寫法要比單純的for迴圈的方式，要更簡單了一些。

題外話，Java是自1.5後才提供enhance foreach。不過還記得我們之前有提過，Design pattern是無關乎程式語言的。即始Java 1.5才提供foreach這種語法，早在更早之前，就有其他的Iteratgr介面可供使用。

結論

這一篇是使用與Simple factory相同的例子做示範，簡單介紹一下iterator pattern。 Iterator不只是可以next，也有可以previous、也可以直接first或last。沒錯，就是我們一般在網頁上最常看到的paging。

大家是否有注意到，我們常用的jdbc ResultSet也有相同的味道喔！

Design Pattern 102: Factory Method

2015-03-29T20:52:00.003+08:00

這是factory method pattern的class diagram

之前有稍微對Design Pattern做了一些描述，大概說明了一下什麼是design pattern。今天會講解一下其中的一種：factroy methody...

factory method 主要是當需要產生複雜的物件的時候使用。由於產生物件的過程複雜，封裝起來，讓使用物件的人不需要知道產生的過成，就可以取得這個物件。

沒什麼用的Hello World...

比方說我有一個書櫃的類別(BookShelf)。有書櫃就有書，不過書並不是我們這次要講的重點，所以我們跳過… 。

回到書櫃這個類別。

書櫃的建構過程如下：

... 前面還有50行程式碼...
List<Book> books = bookDao.findBookBy(shelfId);
BookVo[] bookVos = new BookVo[books.size()];
... 假設這裡有100行程式碼...
BookShelf bookShelf = new BookShelf(bookVos);
Shelf shelf = shelfDao.findShelf(shelfId);
bookShelf.setShelf(shelf);

於是我用一個function(在Java 稱為method)將這麼多程式碼封裝起來，…

public class ShelfFactory {
    public BookShelf getBookShelf(String shelfId) {
        ...前面的150行程式碼...
        return bookShelf;
    }
}

於是當有人要取得BookShelf物件時，如果直接用new BookShelf()是行不通的，而且為了達到更好的封裝效果，建構子只有在相同一個package才能呼叫。用戶端如果要取得BookShelf物件，只要使用可以很快速取得的ShelfFactory，就可以取得很裡雜的BookShelf物件…

... 前面只要2行可以取得context物件...
ShelfFactory boFactory = context.getBean(ShelfFactory.class);
BookShelf bookShelf = boFactory.getBookShelf("POMO");

眼尖的讀者，可能開始在猜context物件不會是Spring framework裡面的東西吧？沒錯，就是你所想的那種東西。

通常來說Factory的function，都會使用static的宣告，因為Class是可以直接取得的。

很常用的factory method pattern

前面的hello world用處不太大。不過還記得我在之前的文章裡介紹，pattern 就是一再重複的東西，其實你時常在用，只是沒注意到。我舉一些例子…

Calendar calendar = Calendar.getInstance(); //取得Calendar 物件
Logger logger = LoggerFactory.getLogger(getClass()); //取得logger物件
WebApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(servletContext); //取得Spring context物件

這幾個物件，大家應該每天都在用，尤其是logger。

如果你有用過Spring 那你一定有用過

還有如果你有使用過Spring famework，你就一定有用過的一個factory method。還記得上面那個看似沒用的hello world 裡，利用spring framework取得ShelfFactory 物件的部份嗎？也是使用simple facotry pattern喔。

ShelfFactory boFactory = context.getBean(ShelfFactory.class); //其實spring 產生bean的過程是很裡複雜的

如果去trace Spring 的getBean跑最後，大概是這樣的一段，你說建構這樣一個bean會不會很複雜…

public <T> T getBean(Class<T> requiredType, Object... args) throws BeansException {
    Assert.notNull(requiredType, "Required type must not be null");
    String[] beanNames = getBeanNamesForType(requiredType);
    if (beanNames.length > 1) {
        ArrayList<String> autowireCandidates = new ArrayList<String>();
        for (String beanName : beanNames) {
            if (!containsBeanDefinition(beanName) || getBeanDefinition(beanName).isAutowireCandidate()) {
                autowireCandidates.add(beanName);
            }
        }
        if (autowireCandidates.size() > 0) {
            beanNames = autowireCandidates.toArray(new String[autowireCandidates.size()]);
        }
    }
    if (beanNames.length == 1) {
        return getBean(beanNames[0], requiredType, args);
    }
    else if (beanNames.length > 1) {
        Map<String, Object> candidates = new HashMap<String, Object>();
        for (String beanName : beanNames) {
            candidates.put(beanName, getBean(beanName, requiredType, args));
        }
        String primaryCandidate = determinePrimaryCandidate(candidates, requiredType);
        if (primaryCandidate != null) {
            return getBean(primaryCandidate, requiredType, args);
        }
        String priorityCandidate = determineHighestPriorityCandidate(candidates, requiredType);
        if (priorityCandidate != null) {
            return getBean(priorityCandidate, requiredType, args);
        }
        throw new NoUniqueBeanDefinitionException(requiredType, candidates.keySet());
    }
    else if (getParentBeanFactory() != null) {
        return getParentBeanFactory().getBean(requiredType, args);
    }
    else {
        throw new NoSuchBeanDefinitionException(requiredType);
    }
}

getBean的宣告是：public T getBean(Class requiredType, Object... args) throws BeansException；他的權限是purlic； method name 是getBean，需要傳入requiredType，指定回傳型別，以及一些其他所需要的參數…

什麼是封裝

小時候在學物件導向時，背知道物件導向的三大特性：封裝、繼承、多型。在講解封裝時~~沒什麼用~~的HelloWorld大概是這樣：

public BigDecimal getSalary() {
    return salary;
}

那時總沒什麼感覺，總在納悶為什麼這樣子的封裝會引起世界的潮流。想來是那時真沒什麼實務經驗。實務上封裝的應用，會是像上頭舉的Spring framework裡的getBean這樣。有了封裝，我們只要呼叫getBean這一個method，丟入所需要參數即可，不用花時間去了解這麼複雜的建構過程。

搭配應用

Singleton
Factory method通常會搭配Singleton一起應用。上面的例子其實有搭配了singleton的1/4招─一半私有化(private)建構子─而且還不是完全私有化，因為使用的是
package層級。
Template method
之前的例子，是回傳BookShelf物件，但我可以回傳Shelf物件。使用的人可以不用在意，取到的實例是BookShelf或是PromtionShelf。

結語

Factory method是很簡單的一種pattern，他也可以算是其他應用的基礎。如果以武功招式來說，他可以算是起手式。大家要好好熟悉呀！

Factory method 算是一種起手式

更新

2015-05-02: 將原名稱為simple factory改為factory method.

如何取得CVS的檔案異動清單

2015-03-25T22:40:00.001+08:00

CVS 是一個老牌的版本控管軟體，N年前應該真的是很夯，甚至可能是第一個版本控管軟體，不過這幾年幾乎快被其他的東西取代掉了。雖然覺得是已經快淘汰的東西，不過有工作上有需要用到，還是得研究一下。今天主要是介紹，如何在CVS上取得需求異動清單。

Google 上搜尋CVS已經變成藥局了(圖片引用自CVS Health官網 )

基本上，以目前所看到的一些GUI工具，似乎沒辦法很順利的提供這樣的功能，所以這個方法主要是採用命令列方式來進行。

我什麼都不想知道，只想要結果…

基本上我是不建議這樣子的做事態度。我們應該像孩童一樣，隨時保持著一顆亦子之心，隨時充滿著好奇心。不過有時候，老闆跳腳了，工作逼急了，這也是沒辦法的事。

簡單來說就是下這樣的指令：

cvs -d ${CVS_ROOT} log  -d "2015-03-23 00:00:00<2015-03-25 00:00:00"  -SN -w${LOGIN_USER}

產出結果會是這樣：

Working file就是修改的檔案。注意-w與${LOGIN_USER}必需連在一起。

充滿好奇心的小朋友想知道的事

你是這樣的人嗎？那請繼續看下去…

我剛輸了3小東西？

這指令的意思是查詢日期區間2015/3/23 ~ 2015/3/25，這段時間區間的log，而且是${LOIGN_USER}提交的東西。

所謂的CVS

就如同SVN一樣，CVS也是一種規格，也有許多版本的實作。有時候我們在網路上找的一些文件，或許有這樣的功能，但下了指令後，才發現根本不行。這並不見得是文件有錯，只是很可能你所使用的實作版本，並不支援這樣的功能。

時間格式

CVS這裡的時間格式是採用 ISO 8601 而且沒有時區 。網路上有文件說明可以下-z這個參數帶時區，不過在我的執行環境下是找不到這個參數。這很可能是之前講的是基於實作版本的差異。大家在使用的時候，還是要去參照實作的官方文件。

那什麼是沒有時區？

稍微岔開講一下時區的故事。

當你在看這篇文章的這個moment，地球上每個人的手錶上所指的時間都有些許的不一樣。當然，或許這是因為你的錶和我的錶不是同一支所導致，但更多時候是因為我在台灣你在香港，地點不一樣的關係。這就是時區。那麼每個人所在地的時區都不一樣，總得有個標準呀；不然當我告訴你：

「我這個檔案已經在2015/3/24 07:25:08 提交到版本控管了，你可以去看一下。」

結果你一看手錶，

「現在才 2015/3/24 06:25:08, 你在騙誰…？」

這樣的情況，那就莫妙奇妙了。這就是時區造成的影響。那麼我們要以什麼為標準呢？

標準就是UTC。 UTC(Coordinated Universal Time)是世界標準時間的縮寫，指得是英國那一帶的時間。不過並不是專門指常見的格林威治。當提到格林威治的時間時，是用GMT，所以GMT才是指格林威治標準時間(Greenwich Mean Time，GMT)。其實GMT也是一個標準，以實際數字上來說，2個是差不多；差異的地方除了一些歷史的因素外，還有一些天文與科學的原因，但是我們還是先到此打住吧！我們還有其他的東西需要研究。

好，講完標準了，現在來講時區。

假設我現在人在台灣，如果英國那一帶(不是格林威治喔)的時間是2015/3/24 7:25 那麼台北的時間你可以記作2015-03-24T15:25+08:00 。沒錯，我現在手錶的時間是其實是下午3點多。我沒那麼勤奮，台灣時間早上7點25分提交程式。雖然之前的範例區間是跨了48小時，但是其實我想查的是「台灣時間 2015/3/24 下午3點左右時，由我所提交的日誌」記錄，然後藉由查詢日誌，取得異動清單。

這樣當你了解CVS的日期格式之後，你可以正確的輸入他的時間區間了。之前提到CVS log的時間 沒有時區 的概含，因為他的時間是UTC─世界標準時間。所以當你在查詢的時候，也必需要自己換回UTC的時區。

cvs -d ${CVS_ROOT} log   -d "2015-03-24 07:00:00<2015-03-24 08:00:00"  -SN -w%{LOGIN_USER}

參數`-d`的另外用法

-d是指定時間區間。也有其他的用法：

-d "10 min ago"  # 10分鐘以前
-d "10 min"      # 10分鐘以內
-d "2015-03-24<" # 超過 2015/3/24
-d "<2005-10-01" # 2015/3/24 以前

另存新檔

你可以將這些產出結果另存檔案

${剛才輸入的一連串指令} > chage_list.txt

>是將輸出結果轉向。 Linux上很常用到這樣的指令。

結論

詳細的參數，可以參考線上文件，或是直接下--help看參數的用法，只不過基於這重還不知道有沒有人在維護的東西，可能有時候，這文件也不見得會準，還是要實際使用看看才會知道。

Design Pattern 101

2015-03-24T01:40:00.001+08:00

這是strategy pattern

引言

第一次寫design pattern 的文章。這一系列的文章也是想寫很久了，今天總算是開宗第一篇…。

什麼是pattern

Pattern ，中譯名叫「樣式」，就是每次在這樣的情況下，大家都會那樣做的一種行為模式。

比方說，在電影情節裡，只要有公主，就一定會有魔王；有魔王就一定會閒閒沒事跑去抓公主或到處去姦淫擄掠。如果公主被抓了，就一定會蹦出一個英雄，然後正義凜然的會跑去救他。這就是pattern。又比方說，我最近在講給小朋友聽的一些故事裡，不管是白雪公主還是長髮公主，也不管這些女孩子們經歷了多少苦難，但最後一定會和王子過著幸福快樂的日子。(其實我不是很確定白雪公主跟長髮公主的老公，是不是相同一個王子；小朋友不懂問，我也不敢提 )。也不管是三隻小豬還是七隻小羊，甚至是小紅帽，基本上只要你是大野狼，最後一定得死。這也是pattern。

其實我不是很確定這些公主們的老公，是不是相同一個王子

這些童話故事可能離我們稍微遠了一點。沒關係，我舉些生活周遭的例子。

比方說一些文章標題的命名方式：「有錢人不告訴你的十件事」、「券商不告訴你的九件事」、「股市高手不敢說的事」；這是pattern。我們日常使用的應用軟體，不管是wrod、Excel、Chrome Browser，最上一排是功能列，接下來可能會有一些工具列，接下來才會是主要的工作區域；這是使用者界面設計的pattern。也有不少廣告，不論介紹什麼產品，只要經費足夠，就會去找一個公眾人物來代言，不管這個人物有沒有使用過這個產品；這也是pattern。

Pattern 總的來說，就是大家一直都在做的事。雖然是大家都在做的事，可是通常沒講你不會留意到。就如同許多標題殺手：「XXX都在做的事」一樣，不講覺得很神祕，可是講了，你也真的了解了，就會說：「這我早知道了」。 pattern就是這樣的東西。

什麼是design pattern？

這裡提到的 Design pattern 也是一種pattern，只是著重在於軟體系統方面。這是是許許多多的高手，在經歷過許許多多的考驗，整理出幾種常用的程式設計方式，尤其著重於如何配合與使用物件。

Design pattern的歷史

Design Pattern 一開始並不是出現在軟工界，而是起源於建築業。有名的書是由Erich Gamma 等4人所著的Design Patterns: Elements of Reusable Object-Oriented Software，俗稱4人幫，簡稱GoF。裡面一共有23種Pattern、分為3大類。不過時事變遷，已經不再只有這樣了，而Design Pattern的應用也不再那麼單純。有些pattern 可以小小的幾行程式碼或是3~5個類別就可以呈現出來，有些pattern 則是一個framework的精髓所在。Pattern 除了在OO、class 的設計上使用，也導到系統架構上。除了pattern，也有所謂的AntiPattern出現；白話的說法就是：「許多人會犯的錯」。還記得前面所講的，pattern其實是「大家都在做的事」嗎？這「事」也包含了「錯的事」。

Design pattern有那些

GoF所提出來的23種 design pattern列舉如下：

創建型模式
- Abstract Factory Pattern
- Simple Factory Pattern
- Builder Pattern
- Prototype Pattern
- Singleton Pattern
結構型模式
- Adapt Pattern
- Bridge Pattern
- Composite Pattern
- Decorate Pattern
- Facade Pattern
- Flyweight Pattern
- Proxy Pattern
行為型模式
- Chain of Reponsibility Pattern
- Command Pattern
- Interpreter Pattern
- Iterator Pattern
- Mediator Pattern
- Memento Pattern
- Observer Pattern
- State Pattern
- Strategy Pattern
- Template method Pattern
- Visitor Pattern

為什麼要學Design pattern？

有網友解釋，Design pattern 像格鬥電玩裡的連續技，我覺得很貼切。一開始學會了程式的宣告、語法以及hello world，就像會用搖杆移動角色，看起來沒什麼。當你會學會使用函式庫，就好像學會了一些招式，開始有點威力。不過當你了解到可以將某些招式組合起來成為連續技，並在不同時機點上使用，就可以對對手造成不小的傷害，這就是design pattern。

基本上pattern可以說是高手們的心得與結晶、他們歸納出來的武功秘笈。高手們都這樣做，一般庸手可以不這樣做嗎？好吧，這個理由對我來說是有牽強了點。我一向主張不盲目的依樣畫葫蘆。

其實學會design patten 可以讓你可以快速的看懂別人的程式碼，自己撰寫出別人可以看得懂的程式碼；不再維護系統後不怕被人追殺。但是在剛學的時候需要注意，不要為了使用pattern而用pattern，這樣很容易走火入魔。這就好像連續技用錯時機點，也往往很容易被對手KO。

需要先會什麼

UML。

大多數的design pattern教學都是使用UML來做為描述。 UML 不需要全部都了解，只要知道sequence diagram與class diagram 兩張圖就可以了。也不見得需要會畫，但是需要看得懂。

一種程式語言

我建議Java。建議Java的理由不是因為他特別好、特別帥，而是因為我比較熟。基本上，只要是屬於OO導向的，其實任何一種語言都可以。沒錯，design pattern 無關乎語言種類。

話說回來，所謂的物件導向，也是「沒講你不會留意到」的東西呀！

SVN 102：SVN使用上的一些小技巧

2015-03-18T21:49:00.000+08:00

前言

前一陣子寫了一篇文章，有提到我平常如何使用SVN；今天這篇文章繼續這個主題...

小技巧

移動常用功能到右鍵選單第一層

你可以在任意一處點選 右鍵>Tortoise SVN>Setting>General>Context Menu開啟設定視窗，將常用的功能放到右鍵選單第一層。

因為我時常會檢視log，所以放了show log在第一層。這樣我就不用滑鼠移動2次，可以減少一些時間

修改忽略名單

在我電腦上面，或是工作環境下，有些東西不應該上版本控管。在這種情形下，我就會在全域環境設定下，將那些檔案，設為忽略名單。設置全域忽略名單在右鍵>Setting>General。設置忽略名單，可以讓你不會不小時將不該進行版本控管的檔案進行版本控管。

這裡的設置是用空白做分隔，可以搭配萬用字元(*)。

那麼什麼東西應該通常被忽略呢？我舉一些例子：

暫存檔。例如~*、.*(以流水號為開頭，或是沒有檔名只有副檔名的檔案)。
執行檔。例如*.class(Java的執行檔)
日誌。例如*.log。

以下是我本機的設定，不過只是參考而已，各位還是需要依自己的需求來進行設定。

*.o *.lo *.la *.al .libs *.so *.so.[0-9]* *.a *.pyc *.pyo __pycache__ *.rej *~ #*# .#* .*.swp .DS_Store .* ~* *.class classes *.log ~* .*

變更檔名

你可能會覺得奇怪，變更檔名不是直接使用F2變更就好了，為什麼還要特定用Tortoise 來變更呢？主要是因為log的關係。如果只是單純的使用Windows 作業系統的F2變更檔名，在SVN的log中只會呈現：少了一個檔案與多了一個檔案，這樣的資訊；不過如果使用Tortoise SVN來變更檔名的話，在log會顯示原來的檔名, 就以知道「原來這個檔案是由另外一個檔案變更過來的」。

我們可以知道DynaViewResult.java是由DynaViewResultSet.java變更而來的

移動目錄或檔案

方法很簡單。用右鍵進行拖曳的動作，放開滑鼠後，會出現快速選單。選擇Move versioned item(s) here。

SVN系列是Tortoise 專屬的功能，當然，你也可以選擇移動順便改檔名，或是複製。當然，移動的目的地是需要已經進入版本控管。

復原到特定版本

如果直接點右鍵的update，是會將目前工作區域直接update到server最新版本。點選 右鍵>Tortoise SVN>Update to revision可以將工作區域回到特定版本。

比較檔案

如果一個檔案在本機上有了修改，這時點選右鍵>Tortoise SVN，會有Diff這個選項，可以比較工作域的檔案與server目前的檔案的差異。也可以選擇Diff with previous version比較server最近版本與上一版的差異。

Log視窗的妙用

呼叫出log視窗後，在log上點選右鍵，有許多功能，是針對該版本檔案的操作。

以下幾個是我常用的功能：

Cmpare with working copy。可以比對該版本與本機檔案的差別。
Compare with previous revision 比對該版本與前一版本的差異。
Create branch/tag from revision直接從這個版本建立。
Merge Revision to 將某個branch merge到這個版本。
Export 匯出這個版本的檔案。匯出的檔案是不包含.SVN控制目錄。

檢視SVN server上的檔案

你可以點選repo-browser 來檢視目前server上資料或目錄架構。

Switch

這個功能在之前的文章裡有提過，是切換branch用的。

其實還有許多功能

Tortoise 的功能很多，不過不管你在本機上如何操作都不用擔心，只要沒有commit，隨時都可以重新在update或是revert回去，大家可以放心的試試。

我平常如何使用SVN？

2015-03-17T10:53:00.001+08:00

身為一個軟體開發者，你一定要知道如何使用SVN。我稍微介紹一下，我平日如何使用Tortoise SVN…

什麼是SVN

Subversion是一個開放原始碼的版本控管系統，簡稱SVN。目前由Apache維護。基本上SVN作者是打算令SVN可以取代CVS(也是另一套版本控管系統)，所以在許多地方SVN與CVS是很相像的。你可以直接在令命列模式下，下指令操作SVN，也有一些現成的GUI(Graphical User Interface，使用者圖形介面)來操作。比較有名的是 TortoiseSVN(本篇重點)；搭配Eclipse Plugin，你可以服用 Subclise。

Tortoise SVN
Subclipse

SVN除了可以當檔案改壞時，將檔案回復到之前的樣子，也可以對相同產品、不同版本間的程式碼，進行管理。

不過如果你只需要進行不同幾器間檔案的同步的話，SVN並不是一個建議的選項。我會建議使用其他的檔案同步軟體，例如FreeFileSync，或是AllaySync。

那麼一天下來，我如何使用SVN？

每天第一件事就是更新

每天早上第一件是就是進行update的動作。先更新別人的檔案，然後才可以在別人已經修改過後的檔案上再增加自己想要修改的部份；不然merge的動作，其實是很累人的。如果是小檔，或者別人改的幅度不太大的話就還好，但如果是在5000行中的檔案，加上了200行的程式碼，要找出這200行可就累人了。

搭配lock 機制，檔案大家輪流改

版本控管理論裡，解決沖突的方式有Copy-Modify-Merge 與 Lock-Modify-Unlock 2種方式。Copy-Modify-Merge就是先取得檔案來修改，如果有沖突的再進行merge。 Loic-Modify-Unlock 是先鎖定要改的檔案(鎖定後其他人都不能再進行修改)，進行修改；等一個人改完這個檔案後，再輪到下一個人改。原則上我會採用第2種機制，做為團隊共同編輯的解決方案。 ~~基於小團隊，偶爾會偷雞採用一下第一種機制~~。

使用Lock-Modify-Unlock的產程如下：

不論要做什麼修改，都需要進行鎖定的動作。於是第一個要改檔案的人可以先鎖定檔案一個沒有被銷定的檔案來進行修改。
修改完後，將檔案儲存起來，並解除鎖定，讓檔案可以給下一個人進行更改。於是下一個人就又可以進行更改了。

Harry先Lock了檔案，並將檔案由A改為A`。 Sally等到Hrry unlock後才可以再lock檔案。圖檔取自SVN 文件

依照產品維運需求，使用branch

我平常的工作，是針對一套已經上線的產品進行維護。基於這樣的需求，會使用大量的branch。那麼我是如何設計我工作環境的branch呢？

一開始建立的branch。

一開始，我會有3個branch：master、 developer、features。 Master是目前已上線的版本，developer 算是beta版，features則是針對每個需求異動所衍生出來的版本集合。 Features底下會有更多的branch，原則上每個branch會對應到一個需求異動。我習慣使用日期編號來當作每個需求異動的版本；當然這並不是一個絕對的作法。另外一種建議是使用有義意的名稱，而首當其衝的第一個問題就是SVN對中文branch名稱的支援程度。

實務上建立的branch

你可能會想知道如何建立Branch。這點Google上已經有不少範例，有空我也會再多做些補充。

Switch

建立完branch後，會將work區域 switch到該branch，然後進行修改。

修改 & Commit

接下來，就是依照團隊合作的方式，是否採用lock機制，然後按照需求進行檔案的修改，最後將修改的檔案commit回SVN server。

重頭戲：Merge

依照上線的狀況會再將branch的程式碼，merge回develop。等到上線一陣子，上線也都沒問題了，就將這需求所異動的程式碼再merge 到master。

如何取得異動清單

有時候，我必需針對這一個異動需求，取得相關的異動清單。不過一個需求異動，可能前前後後改了好幾次，也commit了好幾次。 Tortoise提供了很快速的方法，可以一口氣取得多次commit的異動清單：

針對work點選右鍵。
選擇show log。
選擇該需求相關commit的紀錄。
在log 上點選右鍵，選擇compare revision

由於是使用版本比較的功能，所以必需再多選上一個變動前的版本，這樣才可以進行比較。比方說我上一個需求，最後一個版本是320；這個需求commit了2個版本(321、323)，所以在compare revision時需要選擇包含320這個版本(320、321、323)。

偶爾有需要，使用暫存的儲存庫

由於工作場所的限制，某些協同工作並沒有版本控管的機制。為了確保在修改檔案的可回復性，所以我會在自己的本機建立一個SVN repository。建立SVN repository的方法很簡單，使用Totoise SVN，找一個空的資料夾，點右鍵，選擇create repository就可以建立了。

建立完儲存庫後，我會將每個要改動的檔案，移到另一個資料夾，並提交(commit)到儲存庫上去。這樣我即使改壞，也有一個備份機制。即使多次基於不同的需求，異動相同的檔案，也可以隨時更新回去到上一個版本，或是與更早之前的版本進行比對。

最後

版本控管是我日常工作中很重要的一個工具。我覺得SVN最大的特色，並不是在update回上一個版本，或是檔案備份，而是程式碼branch間的控管 與 使用lock-unlock，來進行協同工作間的檔案同步。不過戲法人人會變，巧妙各有不同；這裡拋磚引玉地提出一些我平常使用的方式。如果大家有其他的用法，也可提出來分享或討論。

延申閱讀

Subversion on windows安裝

如何使用Notepad++ 執行Java

2015-03-13T04:17:00.000+08:00

最近剛好需要使用Notepad++ 來執行一些簡單的動作…。

來看教學吧。簡單的說，

簡單的說

1. 下載plugin

使用Plugin Manager下載NppExec這個Plugin

因為我的環境已經裝過了，所以NppExec在Installed這個分頁裡。沒裝過的朋友應該可以在available分頁中找到。

安裝好之後，外掛模組這個選單應該已經多了一個NppExec這個選項。

2. 撰寫Script

安裝好之後，點選外掛模組>NppExec>Execute，或是F6熱鍵，叫出出script編輯畫面，輸入script。輸入完script後儲存成Java… 或是任何你想要的名字。

javac $(FILE_NAME)
java $(NAME_PART)

3. 執行

撰寫好程式碼後，執行外掛模組>NppExec>Execute，或按F6執行程式碼。你也可以按Ctrl+F6重複執行上一次執行的script。

複雜的說

為什麼要使用Notepad++ 來執行Java

以現在的科技來說，軟體開發幾乎是脫離不了IDE；那什麼時候會使用像Notepad ++這種簡單的文字編輯器來執行Java呢？

其實當初會想找這個解決方案，並不是專門為了Java，而是為了需要學習Perl。沒錯，所以相同的方法，其實也是可以用在其他語言上。透過這樣簡單的工具設定，我可以快速的測試、練習我所撰寫的程式碼，而不需要啟動繁雜、厚重的IDE。你知道的，啟動個IDE，致少需要花個30秒，而啟動NotePad ++ 只需要1秒。當然，IDE有他的獨到之處，NotePad++是無法完全取代。在Java中如果需要撰寫更複雜的程式，還是需要IDE的幫忙。

當然如果多點想像力，你可以直接在裡面撰寫更複雜的script，完成一連串的動作。

Console 被我不小關掉了怎麼辦？

請點選 外掛模組>NppExec>Show Console Dialog。

其他的環境變數

除了`$(FILE_NAME)與$(NAME_PART)外，還有其他的變數，在Script中編輯的時候，也有AutoComplete功能，會自動帶出可使用的變數。以下是說明文件中所截錄的一些變數。

變數	範例
$(FULL_CURRENT_PATH)	E:\my Web\main\welcome.html
$(CURRENT_DIRECTORY)	E:\my Web\main
$(FILE_NAME)	welcome.html
$(NAME_PART)	welcome
$(EXT_PART)	.html
$(NPP_DIRECTORY)	the full path of notepad++'s directory
$(CURRENT_WORD)	word(s) you selected in Notepad++
$(CURRENT_LINE)	current line number
$(CURRENT_COLUMN)	current column number

最後

在NppExec>Help/Doc或NppExec>Help/Manual有說明文件可以參考。有興趣的讀者可以研究看看。

好的日誌配置讓你上天堂，不好日誌配置會讓你抓狂：我如何使用日誌配置

2015-03-11T02:40:00.000+08:00

在開發軟體的過程中，時常需要在畫面上檢視一個變數值。最值接的做法，就是使用System.out.print(value); 。使用print的方式，輸出的標的，預設是標準輸出介面，也就是螢幕。可如果你想知道正在上線中的產品，程式碼中的變數值，這樣的做法就很不恰當了。因為你不會隨時隨地的待在主機前面，盯著螢幕，看著畫面顯示變數值；更甚至，有時因為資料量太多，畫面就這樣一閃而過，根本看不到。這時如果有一個機制，可以將標準輸出存到檔案去，就很理想了。

正文開始

講了那麼多，除了是練練打字、充充篇幅、騙騙稿費外，簡單一句話，就是「介紹logger的機制」。

我在大多數的案子中，使用的是Log4J這個framework~ ，或者說是機制。不過近年改用Slf4j。

Log4j是一個老牌的logger 機制，1999年就出來了，正式發行第1版則是到了2001年的事。不過一直到2006、2007 就沒什麼變動。 2012年才又出了第2版。這也是我為什麼好好用的log4j，會再去接觸slf4j的原因。因為這幾年(2007~2012)幾乎是沒什麼更新。

為什麼要使用logger

一開始在學習程式設計時，不知道 logger 與System.out.pring的分別，當實際有了專案經驗後，才發覺這真是無與倫比的重要。

第一個理由，其實在前段的廢文有提到(那這樣是不是可以就不算廢文？XD)：必需要將訊息保存下來。螢幕會一閃而過，留在檔案中才得以保存下來。
將不同的訊息在不同的地方呈現。一般來說，串流預設的輸出是螢幕。不過如果所有的訊息都一起在螢幕上呈現的話，實在是太雜亂無章，不容易追蹤。而且當遇到執行方式沒有畫面可以輸出的時候，系統就不知道要輸出到那裡去了。另外在J2EE環境下，Container(即一般所謂的Tomcat或是JBoss等AP Server) 通常會將該是螢幕輸出的串流，存到自己的log檔。如果container中有多個AP，則所有AP的log都會顯示在同一份log檔中。在這種情況下，想要僅僅檢視自己負責的程式所產生的log資訊並不容易，而且還有資安的疑慮。
如果在開發時其大量使用System.out.pring顯示變數資訊或其他訊息，要麻是在開發完成前夕，搜尋所有的System.out.print，然後刪除，要麻就是直接放在那裡，任由訊息輸出，降低系統效率。這時如果在砍掉System.out.print的時候，萬一不小心砍錯，導致系統錯誤，就得不嘗失了。

基本上，如果使用log framework，以上的問題，都可以提供良好的解決方案。

Logger 組成原素

所謂的組成原素決對不是風、火、地、水，或是金、木、水、火、土 XD。

Logger

基本上就是logger的實體。通常來說，如果你不是使用System.out.print的話，一般都會是用

Logger this islogger = Logger.getLogger(getClass().getName());
thisislogger.info("This is message~");

變數thisislogger 就是一個logger。通常logger有自己名稱(指得不是變數名稱而是getClass().getName())。 Log4j的建議與一般慣例是使用package的名稱。這可以讓logger有良好的繼承機制。當然，如果你想直接使用像"AP"這樣的名稱也是可以，不過這樣在管理上可能就不是那麼容易。

Appender

簡單來說，就是log訊息的輸出地。(其實我也不知道它為什麼要叫「appender」；叫「output」這樣的名字，不是比較直覺…)。以log4j來說，他至少提供了可以將log訊息導到consol上或是實體檔案上的功能。 Slf4j這個log framework 甚至提供可以將log訊息存到DB的功能。 (log4j不確定是否也提供相同的功能)。

Level

指的是logger的輸出等級或是訊息的顯示等級。訊息輸出的等級必需高於設定檔指定的顯示等級，訊息才會被記錄下來。例如：

如果設定檔中(以log4j為例)是這樣設定：

log4j.appender.foo=info

這是說明了「我有個logger叫foo。他的輸出等級是info」。而在Java中這樣撰寫：

foologger.info("this is info message");
foologger.debug("this is detail message");

這說明了我記錄了2個訊息，一個是使用info等級來記錄，一個是debug等級來記錄。在這樣的配置設定下，只有info等級的訊息會被紀錄下來。

Layout

簡單來說，就是訊息的格式。

舉個範例(還是以log4j為例)：

log4j.appender.foo.layout.ConversionPattern=[FOO]%d{HH:mm:ss S} %5p %c{1}:%L - %m%n

%後面接的都是參數。當然，參數的意義，請參見各log framework的文件。

我的經驗

一個系統裡，可以設置多個logger，讓每個logger，因應不同的情況輸出到不同的地方，或是多個地方。 我舉一些例子。

Framework 的logger，通常為最低，而且輸出是畫面

因為log4j是很老牌的log framework，許多framework 也都會使用。像Spring或是第三方frameowrk裡的logger我通常會使用最低等級的level ，並且輸出到console appender上。因為我會需要去看spring裡的變數時，通常是在開發階段。這樣的階段，也通常會有console可供使用，而這些log資訊，產生完，看看、確認過後就不再用了，就真的可以讓他閃過了無痕。也不需要存在硬碟裡浪費空間。當然這樣的logger，訊息量有時候會很大，console如果buffer 不夠，在螢幕中也時常會一起閃過了無痕，所以看狀況，有時也會放到file裡去。

log4j.org.springframework=debug, spring
log4j.appender.spring=org.apache.log4j.ConsoleAppender

對外間接的程式碼中，使用中等級的logger，並保留到實體儲存體

有時候，我會在與對外系統間接的地方安插logger。這樣的logger，主要是用作稽核，確定傳出去的資料或是接受到的資料是正確的，以釐清資料流責任。如果是外部系統傳入了與規格不合的資料，而導致回傳結結果錯誤，或甚至系統錯錯誤，馬上就可以提出證據，立馬將責任丟出去， XD。這樣的logger，我通常都會使用info等級，並存放在DAO中，因為通常與外部系統間接的地方，都是在DAO。

規格不確定的地方使用略高等級

比方說設計階段明明說好了這個變數只有4種值，執行時或上線後卻跑出了第5種，這時候我除了會做error handle(可能會讓程式繼續跑下去)，也會使用略高的訊息輸出等級來記錄訊息，這樣可以比較一目了然。另外像基本資料、或是前提假這類的資訊，如果handle 到error，我也會使用略高等級的等級來紀錄。

稽核型態的logger，會使用中高等級來記錄訊息

比方說如果我想監控系統使用人員，可能就會使用這樣的logger：

logger.warn("一個人從"+ logFromIp+ "執行了"+requestUrl);

如同之前稽核作用的log，這樣的log訊息，自然也是會放在實體儲存體中。

我在前面有的一些地方，有提到實體儲存體，而不使用檔案，是因為有時候可以依情況，將log儲入檔案或是DB。

Exception使用error訊息等級

Try-catch的地方，我一般會使用error訊息等級來記錄Exception；而且Exception都會記錄stacktrace。在Layout的部份，也都會儘量可以指出程式碼行號。指出程式碼行號有2個好處：第一，可以很明確的指出錯誤拋出的程式碼。第二，如果你發現訊息的行號與程式的行號不一致，這只表示一件是：你現在看的程式碼與實際執行的程式是不同的。例如：這個訊息在程式碼中，明明是第3行，可是log卻說在第5行，這表示你上錯檔案、或是執行到不同版本的程式。

3 logger.info("這個訊息應在第三行");

[FOO] 20:44:35 105 info Test:5 - 這個訊息應在第三行

開發時期資訊使用低訊息等級

一般來說IDE的Debug模式是可以顯示執行中變數的值，但這通常都是限制執行環境必需要在IDE中才可以。不過當你無法在IDE中執行的時候，就必需要靠傳統的「插旗標」的方法，來顯示變數值。通常像「插旗標」用的log，我都會使用最低等級來顯示─debug，或甚至是trace。有時候，在追蹤程式的流程時，也是同樣會使用低級的logger。

logger.tracert("變數A:" + a );
logger.debug("取得資料庫連線");

因為這些情況，大多在開發時期所會需要使用到的資訊，不需要在上線時也浪費效能與系統資源來顯示這些訊。簡單來說，開發時期所需要用的資訊，我都會使用低訊息等級來輸出。

依照不同的環境，有不同的配置檔

例如在開發環境下，我會將輸出全部導到console上，而在正式環境中，則將輸出全部導到檔案，或是資料庫中。當然，這必需搭配相關的佈署策略與工具，可以使用相同的source code，依不同的執行命令或參數，使用不同的設定檔，產生2種不同的war檔。實務上的作法，當然是另外一篇文章的事。 如果輸出是檔案的話，也一般都會設成一天一個檔。

結語

這篇文章大概介紹了logger的組成成份，還有對我平常如何使用logger的一些經驗匯整。使用方式並不是絕對，只是我個人的經驗與看法，有其他的方式或經驗也歡迎大家提出來一起討論。

Perl 教學 102

2015-03-06T00:25:00.000+08:00

如果你搞不清楚Perl與Pearl的的區別，請先參考 Perl101。 Perl101 會告訴你什麼是Perl、如何安裝，與一個簡單的Perl Hello World。想更了解Perl？請繼續看下去…

註解

註解使用 #。
Perl沒有區域註解。

資料結構

專業術語叫「資料結構」，不過我覺得用白話一點的資料型態，會比較好標示出這一段的重點。

Perl 只有3種資料型態: Scalar(純量變數)、Array(串列變數)和Hash(雜湊)；沒有Boolean、日期，也不區分浮點數、整數之類的。

Scalar是文字、數字，或是參考(Reference) 。Array是一堆scalar在一塊，用數字做索引；Hash則是用KEY做索引，而且沒有固定順序，有點類似Map或是Dictionary。 Scalar使用$做為變數開頭，例如：

$thisIsScalar=100; # 最基礎的Scalar變數
$thisIsArray[0]=100; # thisIsArray變數的第一個元素
$thisIsHash{"K"}=100; #KEY值是K的元素

如果你想表示一整個Array或是Hash，則使用@或是%。例如：

@thisIsArray;
%thisIsHash;

但你是也可以特別的指出裡面的某些元素，例如：

@thisIsArray[0]=100;
%thisIshash{"K"}=100;

於是初學者就會很容易搞不清楚@與$的差別了… XD。

$thisIsArray[0];
@thisIsArray[0];

其實這兩種寫法或許是不同的語意，但是是相同的東西。Perl的一個好處就是相同的東西可以有不同的寫法，怎麼寫都對，非常容易上手！不過這個卻是我在 Perl 101 中所提到的，我所不喜歡Perl的原因。 同樣一件事情，有不同的寫法。

陣列(Array)與串列(List)的差別

駱馬書(Perl界的聖經，Oreilly出版)上說:

基本上("A","B","C")這些是串列(list)。當串列assign 給一個變數時，這個變數稱陣列。
串列是純量的有序集合。陣列是一個包含了串列的變數。

老實說，一開始看到這段翻譯時，實在不知道在翻什麼。看完整章節後，覺得大概的意思是：Array是表示整個集合，使用@作為識別，如果你想表達單一元素，則使用$來表示。致於詳細的內容就要請各位參照書籍了。

基本上在大多數有關於Array的操作，一般都是使用$thisIsArray[$i]來進行。因為前面有提到，原則上@thisIsArray是表示整個串列。不過你可以在@thisIsArray後面，使用[]來特別示要取得一個陣列的那些元素，所以@thisIsArray[0]其實是@thisIsArray[0,2,5]的變型。

有了這個概念後，同樣可以套到Hash上去。我們同樣可以用%thisIsHash來表示$thisIsHash{"K"}+$thisIsHash{"L"}。

初始化

直接舉例。不過如果想學好Perl的朋友，最好是開文字編輯器，自己實際全部敲一次。

$thisIsScalar = "A";
$thisIsScalar =100;
$thisIsArray[0] = 100;
$thisIsArray[1] = 200;
@thisIsArray = (100,200);
$thisIsHash{"K"} = 100;
$thisIsHash{"L"} = 200;
%thisIsHash = ("M" => 100,"N" =>200);
@thisIsHash{"O","P"}  = (100,200);

這裡歸納一下。原則上，一般的變數操作，單一給定型的，都是針對Scalar進行賦值。所以不管是 thisIsScalar、thisIsArray、thisIsHash 都是使用$。一次給定型的，Array使用(、)給值，Hash使用()加=>來賦值。

這裡要特別指出@thisIsHash{"O","P"}，他的前面綴符號之所會是@，是因為他一次初始化了2個值。

比較特殊的操作

$#x 取@x最後的index值

網路上的文章百百種，還是要看看官網的文件

一開始學習的Perl時，會依自己以前的經驗來解讀Perl。不過在學習的過程中，建議還是回過頭來，閱讀一下官方文件，去了解Larry(Perl發明人)的想法。其實整個學習Perl的過程，可以說是就是學習Larry的想法，而官網的文件就是最原生、表達作者想法的媒界。

(不知道有沒有續)

Perl 教學 101

2015-03-03T11:47:00.000+08:00

因為工作的關係，需要使用Perl做為開發語言，所以最近花了一些時間，鑽研一下Perl這個語言！

寫在前面

引言

Perl是一種~~老掉牙~~歷史悠久的語言了，不過他跟Pearl沒有關係。能夠有這麼長的歷史，一定有他的優點。不過這樣的優點，從我的觀念來看，並不是一件好事。詳細的情形，我在後面會描述。基於與我觀念背道而馳的理由，我應該不會太花時間繼續鑽研下去，能應付工作已經足夠。不過既然已經花時間鑽研，就記錄一下。

故事的開始是這樣的

Perl是script型態的程式語言。最初設計者拉里·沃爾（Larry Wall）。最初發行時間約在 1987年12月18日發表。目前，版本中包含Perl 5以及Perl 6（開發中）。

Perl借用了C、sed、awk、shell指令碼以及很多其他程式語言的特性。談到Perl有幾個特性：

內部整合了正規表式的功能，
巨大的第三方代碼庫CPAN。你可以在CPA找到各代各樣的模組。截至2012年4月，它已經有超過9500個作者寫的24500多個模組。
靈活的撰寫風格。 (不過這卻是我最不喜歡-或者是說唯一不喜歡-的地方。)

2000年開始，目前拉里·沃爾開始開發Perl 6，來作為Perl的後繼；不過，Perl 6語言的語法有很多轉變，所以Perl 6被視為Perl家族中的另一個語言。

Perl語言的應用範圍很廣，很多是使用於CGI。而除了CGI以外，還被廣範應用於圖形編程、系統管理、網路編程、金融、生物以及其他領域。由於其靈活性，Perl被稱為手稿語言中的瑞士軍刀。

(引用自Wiki)

你只會做一次的事

選擇開發工具：推薦IDE

幾乎所有的語言，都可以使用純文字編輯器作為開發工具，而不需要特別去使用IDE。Perl也是一樣。只要使用你所習慣的純文字編輯器就可以。不過有一個訴求：要能夠正確辨識檔案格式，例如檔案存檔是存成UTF8 或是 ANSI 等格式。這不是限制，但是最好是可以做到，不然在開發或是學習過程中，可能會發生許多你搞不清楚原因的問題。因為有許多人是使用UltraEdit做為預設的純文字編輯器，而UltraEdit預設則是使存成windows預設使用的 ANSI 格式。如果使用UltraEdit的朋友，稍微注意一下即可。

如果硬要推薦一款IDE的話，我推薦Padre這款IDE。理由是：

也有人推薦它，應該還好上手。
免費。

安裝

請到官網下載Perl的執行環境。 Perl的官網是www.perl.org。目前(2015/02/25) Perl 官網提供下載的版本，除了作業系統不同外，Windows 版還特別多了一個StrewBerry版。如果你是Windows 作業系統，請下載AciveSState版。下載時，請注意自己的32/64版本。下載下來後，無腦的執行下一步即可。

Hello World

大多數的語言教學，一開始就是給你一個Hello World。基本上Hello World沒有任何用處，但是它可以讓你對那種語言，可以有一些親切感。

Perl的Hello World很簡單：

用你的文字編輯器，撰寫以下的程式碼，存檔(檔名為HelloWorld.pl)。記得存成UTF8格式。

print "Hello World, Perl!!";

在DOS模式下執行

perl HelloWorld.pl

順帶一提，如果印出的字樣有中文，則必需存成ANSI格式。

print "你好, Perl!!";

當然，實務上不是這樣做。不過這是屬於進階的議題。至於建議存成UTF8或是ANSI 則是看需求。

(待續)

進行Java 除法運算時，不提醒你很容易埋的bug

2014-11-18T00:04:00.000+08:00

Java的除法，有一些很基礎的操作，這些操作平常不會發生問題，但一旦發生真的是因為這些操作導致的bug，也真的是很難查覺得出來。

小學數學規定：「除數不能為零」 XD，原來事情不像小學生想得這麼簡單。

「除數不能為零」不是只是『規定』，他其實是有不得以的原因

Wiki 有一堆不是專業數學碩士看不懂的證明，說明它不只是「不能為零」，而且是「必需『不』為零」，不然1會等於2…。

不過不管除數可不可以為零，在Java裡，其實是可以的…。

public class FloatOperation {
    private static Logger logger = LoggerFactory.getLogger(FloatOperation.class);

    public static void main(String[] args) {
        div("案例1", 6, 4);
        div("案例2", 2, 3.0);
        div("案例3", 2.3, 0.0);
        div("案例4", 2.3, -0.0);
        div("案例5", 0.0, 0.0);
        div("案例6", 0.0, -0.0);
        div("案例7", 0.0, 0.1);
        div("案例8", 0.0, -0.1);
    }

    public static Double div(String title, int a, int b) {
        double x = a / b;
        logger.trace("{}: {}/{}={}", title, a, b, x);
        return x;
    }

    public static Double div(String title, double a, double b) {
        double x = a / b;
        logger.trace("{}: {}/{}={}", title, a, b, x);
        return x;
    }

以上範例程式執行結果如下：

278 [TRACE] t.b.b.FloatOperation[22]: 案例1: 6/4=1.0
281 [TRACE] t.b.b.FloatOperation[28]: 案例2: 2.0/3.0=0.6666666666666666
281 [TRACE] t.b.b.FloatOperation[28]: 案例3: 2.3/0.0=Infinity
282 [TRACE] t.b.b.FloatOperation[28]: 案例4: 2.3/-0.0=-Infinity
282 [TRACE] t.b.b.FloatOperation[28]: 案例5: 0.0/0.0=NaN
282 [TRACE] t.b.b.FloatOperation[28]: 案例6: 0.0/-0.0=NaN
282 [TRACE] t.b.b.FloatOperation[28]: 案例7: 0.0/0.1=0.0
282 [TRACE] t.b.b.FloatOperation[28]: 案例8: 0.0/-0.1=-0.0

簡單來說, 做幾個結論：

除數為「整數」0 時會丟異常。
除法的時候，除數、被除數任一為浮點數，結果即為浮點數。若都是整數，則結果為整數，就如同浮點數轉型為整數一樣，小數點後的東西都被刪光了。案例1即為例子。
0.0做除數而被除數不為0時，得到的是一個分正負的無窮大(Infinity)，看是+0f或是-0f。
當兩個數的絕對值均爲0.0時候，商等于NaN。
如一般所認知的，0.0/任何不為0的數，都為0。而且這是有帶正負符號位的；符號位由被除數決定。當然，如果負負的話，還是會得正。

Double、Float都有提供static 與非static 的inFinite與NaN的判斷API，在使用除法運算時，要使用這些API來進行安全判斷.

Double、Float類中都提供了一些常數，可以用這些常數來判斷正無限大或負無限大。

public static final double POSITIVE_INFINITY = 1.0 / 0.0; 
public static final double NEGATIVE_INFINITY = -1.0 / 0.0; 
public static final double NaN = 0.0d / 0.0;

如何使用Jsoup解析 Html

2014-11-14T01:00:00.000+08:00

話說最近剛好有解析html 的需求。今天介紹一個工具，可以使用Java ，簡單的解析Html─Jsoup。

Jsoup官網

會選擇介紹這套framework的原因幾個：

仍還在持續更新
簡單、快速上手
有足夠的文件

這幾個原因也是我在選擇使用framework的一些考量。有時候我會加上老牌(夠成熟)這樣的一個考量。當然，通常夠成熟也會代表著不見得會在持續更新，或是更新速度已經變慢。

Jsoup不只可以解析Html，還可對Html進行一些變更後產出。Jsoup有以下一些特色：

可以有多種多入，包含URL、File、String。
有多種方式可以取得結點資訊，包含透過DOM瀏覽方式與使用CSS 的選擇器。
變更取得的Html原素
清除使用者所提交的一些資訊
產出所變更的Html

(來源：官網)

如何解析HTML

假設我有一個網頁：

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>聊天室列表</title>
</head>

<body>
<form id="input_form">
    <a href="main.html"> 回首頁 </a><br/>
    <a href="next.html"> 到下一頁 </a><br/>
<input name="button" type="button" id="button" value="登出">
</form>
<table border="1">
  <tr>
    <td>聊天室ID</td>
    <td>聊天室名稱</td>
  </tr>
  <tr>
    <td>123456T890</td>
    <td><a href="chatRoom.html">洛基</a></td>
  </tr>
  <tr>
    <td>12X4567890</td>
    <td><a href="chatRoom.html">阿波羅</a></td>
  </tr>
 </table>
</body>
</html>

他執行起來結果看起來像這樣子：

解析Html的範例程式碼會是這個樣子。

File input = new File("input.html");
Document doc = Jsoup.parse(input, "UTF-8");
Element content = doc.getElementById("input_form");
Elements links = content.getElementsByTag("a");
for (Element link : links) {
    String linkHref = link.attr("href");
    String linkText = link.text();
    logger.trace("link href:{}, link text:{}", linkHref, linkText);
}

執行結果會是像這個樣子：

299 [TRACE] t.b.j.JsoupTest[23]: link href:main.html, link text:回首頁
302 [TRACE] t.b.j.JsoupTest[23]: link href:next.html, link text:到下一頁

要注意的是Element 與 Elements 的差異。顧名思義，Elements 可以跑迴圈。而 Document則是一個Element。一般而言，除非像id這樣的取法，不然所搜尋出來的, 多半是Elements。

Jsoup這個tool，主要的進入點是Jsoup.parse(...)這個API。

Jsoup.parse(...)

如果你已經將File轉成String，可以這樣用：

String htmlSoruce=getHtmlSource();
Document doc = Jsoup.parse(htmlSoruce);

parse可以有許多種輸入，甚至可以直接輸入URL；不過似乎還無法丟參數。更多的使用方式，當然需要詳見 API 啦。

如何取得Html物件

Jsoup取得tag的方式有很多種，使用id只是其中的一種。也可以使用byClass、byTag。不過我喜歡用CSS selector的方式來取得。

什麼是CSS selector？他是一種CSS 在搜尋tag時，所使用的語法。

就如同一般指定tag的方式，CSS也有他搜尋tag的方式，來指定特定tag所要呈現的style。 CSS的搜尋語法，跟jquery似乎是一樣的。這麼複雜的語法，跟行院的動能推動方案一樣，很難用簡單的幾句話說明，~~(其實我也不太會)~~，所以各位如果有需要，可以詳參jsoup Selector的Java doc 。

CSS selector 語法要學其實不會太困難。會的話當然好，但是如果真沒時間學習的話，我們有其他的變通方式。後面我會介紹。

接下來，談一下範例。

比方說我想取得表格(tbody)的內容，需要先取得tbody element。 Tbody element的selector syntax是這樣：

body > table > tbody

如果你閱讀程式碼的功力夠高的話，加上已經了解CSS selector語法的話，可以直接撰寫。小弟不才，使用偷吃步的方式：

Google Chrome 功能列→更多工具→開發人員工具，點選右鍵→Copy CSS path

我們可以使用Google Chrome browser，點選功能列→更多工具→開發人員工具，然後在要取得的元素上點選右鍵。

於是取得表格內容的程式碼範例會是這樣：

File input = new File("input.html");
// String htmlSoruce=getHtmlSource();
Document doc = Jsoup.parse(input, "utf-8");
Elements tbodys = doc.select("body > table > tbody");
Element tbody = tbodys.get(0);
for (Element tr : tbody.children()) {
    logger.trace(tr.text());
}

執行結果如下：

336 [TRACE] t.b.j.JsoupTest[23]: 聊天室ID 聊天室名稱
340 [TRACE] t.b.j.JsoupTest[23]: 123456T890 洛基
340 [TRACE] t.b.j.JsoupTest[23]: 12X4567890 阿波羅

太極科技

Sublime多重選取

如何使用CURL來進行web service測試

輸入參數

輸入帳密

FixedOrderComparator簡介

如何在透過class指定相對路徑

解決方式

重點

如何使用 Struts 1.3如何接收json資料

Java中如何截取固定長的字串

Maven從0開始

我眼中的maven

Apache 官網眼中的maven

深入探討

如何使用jQuery達成動態查詢資料─以jQuery傳送Json給Struts2

前言

架構

知其然

pom.xml

strts.xml

Java action

JSP script

JSP Html

結果

知其所以然

前面沒有提到的

有關於pom.xml

有關於struts.xml

有關於Java action

JSP script 的部份

結語

你的第一隻Java程式─Hello World

安裝

Java 下載

環境設定

環境設定：這是尛？

可以Hello World了嗎？

我要Hello World~~

開始Hello World

學而不知則罔

前面我沒有提到的

結語

物件的具現─如何將物件存成檔案

同場加印

Java 101-Overview

前言

模組

Java SE

Java EE

Bean

結語

Struts1昇級有問題？ 如何將.do導頁到.action

緣起

如何做？

我剛看了小小小？

Dependency

Web.xml

struts-config.xml

struts.xml

Action

結論

Design Pattern 介紹：Memento

限制

結語

Design Patter 103：輪流取得每個物件─Iterator簡介

要怎麼用？

結論

Design Pattern 102: Factory Method

沒什麼用的Hello World...

很常用的factory method pattern

如果你有用過Spring 那你一定有用過

什麼是封裝

搭配應用

結語

更新

如何取得CVS的檔案異動清單

我什麼都不想知道，只想要結果…

充滿好奇心的小朋友想知道的事

我剛輸了3小東西？

Struts1昇級有問題？如何將.do導頁到.action

參數`-d`的另外用法

規格不確定的地方使用略高等級