1     void filerSet(Set<BigDecimal> targetSet, String lower, String higher) {
 2         BigDecimal bdLower = new BigDecimal(Double.parseDouble(lower));
 3         BigDecimal bdHigher = new BigDecimal(Double.parseDouble(higher));
 4 
 5         Set<BigDecimal> returnSet = new HashSet<BigDecimal>();
 6         for (BigDecimal object : targetSet) {
 7             if (isInRange(object, bdLower, bdHigher)) {
 8                 returnSet.add(object);
 9             }
10         }
11     }
12 
13     private boolean isInRange(BigDecimal object, BigDecimal bdLower,
14             BigDecimal bdHigher) {
15         return object.compareTo(bdLower) >= 0
16                 && object.compareTo(bdHigher) <= 0;
17     }

  1     Set<BigDecimal> getSubSet(TreeSet<BigDecimal> targetSet, String lower,
  2             String higher) {
  3 
  4         BigDecimal bdLower = new BigDecimal(Double.parseDouble(lower));
  5         BigDecimal bdHigher = new BigDecimal(Double.parseDouble(higher));
  6 
  7         if ((bdHigher.compareTo(targetSet.first()) == -1)
  8                 || (bdLower.compareTo(targetSet.last()) == 1)) {
  9             return null;
 10         }
 11 
 12         boolean hasLower = targetSet.contains(bdLower);
 13         boolean hasHigher = targetSet.contains(bdHigher);
 14         if (hasLower) {
 15             if (hasHigher) {
 16                 System.out.println("get start:" + bdLower);
 17                 System.out.println("get end:" + bdHigher);
 18                 return targetSet.subSet(bdLower, true, bdHigher, true);
 19             } else {
 20                 BigDecimal newEnd = null;
 21                 System.out.println("get start:" + bdLower);
 22                 SortedSet<BigDecimal> returnSet = null;
 23                 if (bdHigher.compareTo(targetSet.last()) != -1) {
 24                     newEnd = targetSet.last();
 25                 } else {
 26                     SortedSet<BigDecimal> newTargetSet = targetSet
 27                             .tailSet(bdLower);
 28                     for (BigDecimal object : newTargetSet) {
 29                         if (object.compareTo(bdHigher) == 1) {
 30                             newEnd = object;
 31                             break;
 32                         } else if (object.compareTo(bdHigher) == 0) {
 33                             newEnd = object;
 34                             break;
 35                         }
 36                     }
 37                 }
 38                 returnSet = targetSet.subSet(bdLower, true, newEnd, true);
 39                 if (newEnd.compareTo(bdHigher) == 1) {
 40                     returnSet.remove(newEnd);
 41                 }
 42                 return returnSet;
 43             }
 44 
 45         } else {
 46             if (hasHigher) {
 47                 System.out.println("get end:" + bdHigher);
 48                 TreeSet<BigDecimal> newTargetSet = (TreeSet<BigDecimal>) targetSet
 49                         .headSet(bdHigher, true);
 50                 BigDecimal newStart = null;
 51                 SortedSet<BigDecimal> returnSet = null;
 52 
 53                 if (bdLower.compareTo(targetSet.first()) == -1) {
 54                     newStart = targetSet.first();
 55                 } else {
 56                     for (BigDecimal object : newTargetSet) {
 57                         if (object.compareTo(bdLower) != -1) {
 58                             newStart = object;
 59                             break;
 60                         }
 61                     }
 62                 }
 63                 returnSet = targetSet.subSet(newStart, true, bdHigher, true);
 64 
 65                 return returnSet;
 66             } else {
 67                 System.out.println("Not get start:" + bdLower);
 68                 System.out.println("Not get end:" + bdHigher);
 69                 BigDecimal newStart = null;
 70                 BigDecimal newEnd = null;
 71                 if (bdHigher.compareTo(targetSet.last()) != -1) {
 72                     newEnd = targetSet.last();
 73                 }
 74                 if (bdLower.compareTo(targetSet.first()) == -1) {
 75                     newStart = targetSet.first();
 76                 }
 77                 for (BigDecimal object : targetSet) {
 78                     if (newStart == null) {
 79                         if (object.compareTo(bdLower) != -1) {
 80                             newStart = object;
 81                             if (newEnd != null) {
 82                                 break;
 83                             }
 84                         }
 85                     }
 86 
 87                     if (newEnd == null) {
 88                         if (object.compareTo(bdHigher) != -1) {
 89                             newEnd = object;
 90                             if (newStart != null) {
 91                                 break;
 92                             }
 93                         }
 94                     }
 95                 }
 96 
 97                 if (newStart == null) {
 98                     if (newEnd == null) {
 99                         if ((bdHigher.compareTo(targetSet.first()) == -1)
100                                 || (bdLower.compareTo(targetSet.last()) == 1)) {
101                             return null;
102                         }
103                         return targetSet;
104                     } else {
105                         SortedSet<BigDecimal> newTargetSet = targetSet.headSet(
106                                 newEnd, true);
107                         if (newEnd.compareTo(bdHigher) == 1) {
108                             newTargetSet.remove(newEnd);
109                         }
110                         return newTargetSet;
111                     }
112                 } else {
113                     if (newEnd == null) {
114                         SortedSet<BigDecimal> newTargetSet = targetSet.tailSet(
115                                 newStart, true);
116                         return newTargetSet;
117                     } else {
118                         SortedSet<BigDecimal> newTargetSet = targetSet.subSet(
119                                 newStart, true, newEnd, true);
120                         if (newEnd.compareTo(bdHigher) == 1) {
121                             newTargetSet.remove(newEnd);
122                         }
123                         return newTargetSet;
124                     }
125                 }
126             }
127         }
128     }

 1 //過濾的主體邏輯
 2     void filterSet(Set<BigDecimal> targetSet, String lower, String higher) {
 3         final BigDecimal bdLower = new BigDecimal(Double.parseDouble(lower));
 4         final BigDecimal bdHigher = new BigDecimal(Double.parseDouble(higher));
 5 
 6         Predicate predicate = new Predicate() {
 7             public boolean evaluate(Object object) {
 8                 BigDecimal bDObject = (BigDecimal) object;
 9                 return bDObject.compareTo(bdLower) >= 0
10                         && bDObject.compareTo(bdHigher) <= 0;
11             }
12         };
13 
14         CollectionUtils.filter(targetSet, predicate);
15     }

 1 //guava filter
 2 
 3     Set<BigDecimal> filterSet(Set<BigDecimal> targetSet, String lower,
 4             String higher) {
 5         final BigDecimal bdLower = new BigDecimal(Double.parseDouble(lower));
 6         final BigDecimal bdHigher = new BigDecimal(Double.parseDouble(higher));
 7 
 8         Set<BigDecimal> filterCollection = Sets.filter(targetSet,
 9                 new Predicate<BigDecimal>() {
10                     @Override
11                     public boolean apply(BigDecimal input) {
12                         BigDecimal bDObject = (BigDecimal) input;
13                         return bDObject.compareTo(bdLower) >= 0
14                                 && bDObject.compareTo(bdHigher) <= 0;
15                     }
16                 });
17 
18         return filterCollection;
19     }

軟件的度量對于設計者和開發者非常重要，之前只是對這些有一個簡單的了解。今天看來，了解的還遠遠不夠。

一個系統中的所有類的這三個度量能夠說明這個系統的設計上的一些問題（不是全部），這三個度量越大越不好。
如果一個類這三個度量很高，證明了這個類需要重構了。

以第一個度量來說，有下面的一個表格：

CC數值高，可以通過減少if else（switch case也算）判斷來達到目的；
可以通過減少類與其他類的調用來減少RFC；
通過分割大方法和大類來達到減少WMPC.

而Uncle Bob和Jdepend的度量標準應該算是另一個度量系統。

用包中的每個類平均的內部關系數目作為包內聚性的一種表示方式。用于表示包和它的所有類之間的關系。
H=(R+1)/N
R:包內類的關系數目（與包外部的類沒有關系）
N:包內類的數量

被分析package的具體和抽象類（和接口）的數量，用于衡量package的可擴展性。

依賴于被分析package的其他package的數量，用于衡量pacakge的職責。

被分析package的類所依賴的其他package的數量，用于衡量package的獨立性。

被分析package中的抽象類和接口與所在package所有類數量的比例，取值范圍為0－1。
A=Cc/N

用于衡量package的不穩定性，取值范圍為0－1。I＝0表示最穩定，I＝1表示最不穩定。
I＝Ce/（Ce＋Ca）

     if(id!=null && name!=null) {
        //do something
     }else{
        //do something
     }
}

Cyclomatic Complexity （CC） = no of decision points + no of logical operations +1        （1）

Cyclomatic Complexity (CC) = number of decision points +1                                （2）

參考了JDepend的參數和Uncle Bob的《Agile Software Development: Principles, Patterns, and Practices》 （敏捷軟件開發：原則、模式與實踐）

轉自:http://www.keyusoft.cn/Contentview.aspx?year=2005&month=$10&day=$6&postid=123

通過一周左右的研究，對規則引擎有了一定的了解?，F在寫點東西跟大家一起交流，本文主要針對RETE算法進行描述。我的文筆不太好，如果有什么沒講明白的或是說錯的地方，請給我留言。

首先申明，我的帖子借鑒了網上很流行的一篇帖子，好像是來自CSDN；還有一點，我不想做太多的名詞解釋，因為我也不是個研究很深的人，定義的不好怕被笑話。

好現在我們開始。

首先介紹一些網上對于規則引擎比較好的帖子。

1、 來自JAVA視頻網

http://forum.javaeye.com/viewtopic.php?t=7803&postdays=0&postorder=asc&start=0

2、? RETE算法的最原始的描述，我不知道在哪里找到的，想要的人可以留下E-mail

3、? CMU的一位博士生的畢業論文，個人覺得非常好，我的很多觀點都是來自這里的，要的人也可以給我發mail? ?mailto:ipointer@163.com

?

接著統一一下術語，很多資料里的術語都非常混亂。

1、? facts 事實，我們實現的時候，會有一個事實庫。用F表示。

2、? patterns 模板，事實的一個模型，所有事實庫中的事實都必須滿足模板中的一個。用P表示。

3、 ? conditions 條件,規則的組成部分。也必須滿足模板庫中的一條模板。用C表示。我們可以這樣理解facts、patterns、conditions之間的關系。 Patterns是一個接口，conditions則是實現這個接口的類，而facts是這個類的實例。

4、? rules 規則，由一到多個條件構成。一般用and或or連接conditions。用R表示。

5、? actions 動作，激活一條rule執行的動作。我們這里不作討論。

6、? 還有一些術語，如：working-memory、production-memory，跟這里的概念大同小異。

7、? 還有一些，如：alpha-network、beta-network、join-node，我們下面會用到，先放一下，一會討論。

?

引用一下網上很流行的例子，我覺得沒講明白，我在用我的想法解釋一下。

?

假設在規則記憶中有下列三條規則

?

if A(x) and B(x) and C(y) then add D(x)

if A(x) and B(y) and D(x) then add E(x)

if A(x) and B(x) and E(x) then delete A(x)

?

RETE算法會先將規則編譯成下列的樹狀架構排序網絡

而工作記憶內容及順序為{A(1)，A(2)，B(2)，B(3)，B(4)，C(5)}，當工作記憶依序進入網絡后，會依序儲存在符合條件的節點中，直到完全符合條件的推論規則推出推論。以上述例子而言， 最后推得D(2)。

?

讓我們來分析這個例子。

?

模板庫：（這個例子中只有一個模板，算法原描述中有不同的例子, 一般我們會用tuple,元組的形式來定義facts,patterns,condition）

P: (?A , ?x)? 其中的A可能代表一定的操作，如例子中的A,B,C,D,E ; x代表操作的參數?？纯催@個模板是不是已經可以描述所有的事實。

?

條件庫：(這里元組的第一項代表實際的操作，第二項代表形參)

C1: (A , <x>)

C2: (B , <x>)

C3: (C , <y>)

C4: (D , <x>)

C5: (E , <x>)

C6: (B , <y>)

?

事實庫：（第二項代表實參）

F1: (A,1)

F2: (A,2)

F3: (B,2)

F4: (B,3)

F5: (B,4)

F6: (C,5)

?

?????? 規則庫：

?????? ? R1: c1^c2^c3

?????? ? R2: c1^c2^c4

?????? ? R3: c1^c2^c5

?

??????

?????? 有人可能會質疑R1: c1^c2^c3，沒有描述出，原式中：

if A(x) and B(x) and C(y) then add D(x)，A=B的關系。但請仔細看一下，這一點已經在條件庫中定義出來了。

?

?????? 下面我來描述一下，規則引擎中RETE算法的實現。

?????? 首先，我們要定一些規則，根據這些規則，我們的引擎可以編譯出一個樹狀結構，上面的那張圖中是一種簡易的表現，其實在實現的時候不是這個樣子的。

?????? 這就是beta-network出場的時候了，根據rules我們就可以確定beta-network，下面，我就畫出本例中的beta-network，為了描述方便，我把alpha-network也畫出來了。

??????

?

上圖中，左邊的部分就是beta-network,右邊是alpha-network,圓圈是join-node.

從上圖中，我們可以驗證，在beta-network中，表現出了rules的內容，其中r1,r2,r3共享了許多BM和join-node,這是由于這些規則中有共同的部分，這樣能加快match的速度。

右 邊的alpha-network是根據事實庫構建的，其中除alpha-network節點的節點都是根據每一條condition,從事實庫中 match過來的，這一過程是靜態的，即在編譯構建網絡的過程中已經建立的。只要事實庫是穩定的，即沒有大幅度的變化，RETE算法的執行效率應該是非常 高的，其原因就是已經通過靜態的編譯，構建了alpha-network。我們可以驗證一下，滿足c1的事實確實是w1,w2。

下 面我們就看一下，這個算法是怎么來運行的，即怎么來確定被激活的rules的。從top-node往下遍歷，到一個join-node,與AM for c1的節點匯合，運行到match c1節點。此時，match c1節點的內容就是：w1,w2。繼續往下，與AM for c2匯合（所有可能的組合應該是w1^w3,w1^w4,w1^w5,w2^w3,w2^w4,w2^w5），因為c1^c2要求參數相同，因此， match c1^c2的內容是：w2^w3。再繼續，這里有一個扇出（fan-out），其中只有一個join-node可以被激活，因為旁邊的AM只有一個非空。 因此，也只有R1被激活了。

解決扇出帶來的效率降低的問題，我們可以使用hashtable來解決這個問題。

RETE算法還有一些問題，如：facts庫變化，我們怎么才能高效的重建alpha-network，同理包括rules的變化對beta-network的影響。這一部分我還沒細看，到時候再貼出來吧。

最近插件又加多了,eclipse老是死掉

?

一怒之下,刪除重裝

?

以前因為懶,沒有把插件的目錄和主體的目錄分開,這次也給它分開了

?

?

插件少了之后,eclipse確實快了不少

?

附eclipse啟動參數: -nl en_US vmargs -Xverify:none -Xms256M -Xmx1024M -XX:PermSize=50M? -XX:+UseParallelGC

freemind一個比較不錯free的 mind map 軟件,很多人建議使用這個來管理自己的思路.

?

mind manager另一個比較不錯的mind map的軟件,可以和office兼容.不過是商業的

?

visio,就不介紹了.office里面有的東西.做流程圖來說,確實是比較好的軟件.但是在思路不清楚的時候,很難畫出什么有用的東西來.這點就比不上前面兩個東西了.不過對我來說visio可能更順手,因為我經常畫的是軟件流程圖........

總結一下最近關于domain object以及相關的討論

?

在最近的圍繞domain object的討論中浮現出來了三種模型，(還有一些其他的旁枝，不一一分析了)，經過一番討論，各種問題逐漸清晰起來，在這里我試圖做一個總結，便于大家了解和掌握。

第一種模型：只有getter/setter方法的純數據類，所有的業務邏輯完全由business object來完成(又稱TransactionScript)，這種模型下的domain object被Martin Fowler稱之為“貧血的domain object”。下面用舉一個具體的代碼來說明，代碼來自Hibernate的caveatemptor，但經過我的改寫：

一個實體類叫做Item，指的是一個拍賣項目
一個DAO接口類叫做ItemDao
一個DAO接口實現類叫做ItemDaoHibernateImpl
一個業務邏輯類叫做ItemManager(或者叫做ItemService)

java代碼:?

public class Item implementsSerializable{ ? ? privateLong id = null; ? ? privateint version; ? ? privateString name; ? ? private User seller; ? ? privateString description; ? ? private MonetaryAmount initialPrice; ? ? private MonetaryAmount reservePrice; ? ? privateDate startDate; ? ? privateDate endDate; ? ? privateSet categorizedItems = newHashSet(); ? ? privateCollection bids = newArrayList(); ? ? private Bid successfulBid; ? ? private ItemState state; ? ? private User approvedBy; ? ? privateDate approvalDatetime; ? ? privateDate created = newDate(); ? ? //? getter/setter方法省略不寫，避免篇幅太長 }

java代碼:?

public interface ItemDao { ? ? public Item getItemById(Long id); ? ? publicCollection findAll(); ? ? publicvoid updateItem(Item item); }

ItemDao定義持久化操作的接口，用于隔離持久化代碼。

java代碼:?

public class ItemDaoHibernateImpl implements ItemDao extends HibernateDaoSupport { ? ? public Item getItemById(Long id){ ? ? ? ? return(Item) getHibernateTemplate().load(Item.class, id); ? ? } ? ? publicCollection findAll(){ ? ? ? ? return(List) getHibernateTemplate().find("from Item"); ? ? } ? ? publicvoid updateItem(Item item){ ? ? ? ? getHibernateTemplate().update(item); ? ? } }

ItemDaoHibernateImpl完成具體的持久化工作，請注意，數據庫資源的獲取和釋放是在ItemDaoHibernateImpl 里面處理的，每個DAO方法調用之前打開Session，DAO方法調用之后，關閉Session。(Session放在ThreadLocal中，保證一次調用只打開關閉一次)

java代碼:?

public class ItemManager { ? ? private ItemDao itemDao; ? ? publicvoid setItemDao(ItemDao itemDao){ this.itemDao = itemDao;} ? ? public Bid loadItemById(Long id){ ? ? ? ? itemDao.loadItemById(id); ? ? } ? ? publicCollection listAllItems(){ ? ? ? ? return? itemDao.findAll(); ? ? } ? ? public Bid placeBid(Item item, User bidder, MonetaryAmount bidAmount, ? ? ? ? ? ? ? ? ? ? ? ? ? ? Bid currentMaxBid, Bid currentMinBid)throws BusinessException { ? ? ? ? ? ? if(currentMaxBid != null && currentMaxBid.getAmount().compareTo(bidAmount) > 0){ ? ? ? ? ? ? throw new BusinessException("Bid too low."); ? ? } ? ? ? ? // Auction is active ? ? if( !state.equals(ItemState.ACTIVE)) ? ? ? ? ? ? throw new BusinessException("Auction is not active yet."); ? ? ? ? // Auction still valid ? ? if( item.getEndDate().before(newDate())) ? ? ? ? ? ? throw new BusinessException("Can't place new bid, auction already ended."); ? ? ? ? // Create new Bid ? ? Bid newBid = new Bid(bidAmount, item, bidder); ? ? ? ? // Place bid for this Item ? ? item.getBids().add(newBid); ? ? itemDao.update(item);? ? ?//? 調用DAO完成持久化操作 ? ? return newBid; ? ? } }

事務的管理是在ItemManger這一層完成的，ItemManager實現具體的業務邏輯。除了常見的和CRUD有關的簡單邏輯之外，這里還有一個placeBid的邏輯，即項目的競標。

以上是一個完整的第一種模型的示例代碼。在這個示例中，placeBid，loadItemById，findAll等等業務邏輯統統放在ItemManager中實現，而Item只有getter/setter方法。

原文地址：http://www.cnblogs.com/idior/archive/2005/07/04/186086.html

近日?有關o/r?m的討論突然多了起來.?在這里覺得有必要澄清一些概念,?免的大家討論來討論去,?才發現最根本的理解有問題.

1.?何謂實體?
實體(類似于j2ee中的Entity?Bean)通常指一個承載數據的對象,?但是注意它也是可以有行為的!?只不過它的行為一般只操作自身的數據.?比如下面這個例子:


class?Person
{
??string?firstName;
??string?lastName;

??public?void?GetName()
??{
?????return??lastName+firstName;
??}???
}


GetName就是它的一個行為.

2?何謂對象?
對象最重要的特性在于它擁有行為.?僅僅擁有數據,你可以稱它為對象,?但是它卻失去它最重要的靈魂.?


class?Person
{
??string?firstName;
??string?lastName;
??Role?role;
??int?baseWage;
??public?void?GetSalary()
??{
?????return?baseWage*role.GetFactory();
??}???
}

這樣需要和別的對象(不是Value?Object)打交道的對象,我就不再稱其為實體.?領域模型就是指由這些具有業務邏輯的對象構成的模型.

3.?E/R?M?or?O/R?M?!!
仔細想想我們為什么需要o/r?m,無非是想利用oo的多態來處理復雜的業務邏輯,?而不是靠一堆的if?else.?
而現在在很多人的手上o/r?m全變成了e/r?m.他們不考慮對象的行為,?而全關注于如何保存數據.這樣也難怪他們會產生將CRUD這些操作放入對象中的念頭.?如果你不能深刻理解oo,?那么我不推薦你使用o/r?m,?Table?Gateway,?Row?Gateway才是你想要的東西.


作為一個O/R?M框架，很重要的一點就是實現映射的透明性（Transparent），比較顯著的特點就是在代碼中我們是看不到SQL語句的（框架自動生成了）。這里所指的O/R?M就是類似于此的框架，

4.?POEAA中的相關概念
??很多次發現有人錯用其中的概念,?這里順便總結一下:
??1.?Table?Gateway
????以表為單位的實體,基本沒有行為,只有CRUD操作.
??2.?Row?Gateway
????以行為單位的實體,基本沒有行為,只有CRUD操作.
??3.?Active?Record
????以行為單位的實體,擁有一些基本的操作自身數據的行為(如上例中的GetName),同時包含有CRUD操作.
其實Active?Record最符合某些簡單的需求,?接近于E/R?m.
通常也有很多人把它當作O/R?m.不過需要注意的是Active?Record中是充滿了SQL語句的(不像orm的SQL透明),?所以有人想起來利用O/R?m來實現"Active?Record",?雖然在他們眼里看起來很方便,?其實根本就是返祖.
用CodeGenerator來實現Active?Record也許是一個比較好的方法.
??4.?Data?Mapper
這才是真正的O/R?m,Hibernate等等工具的目標.

5.O/R?M需要關注的地方?(希望大家幫忙完善一下)
?1.?關聯,?O/R?M是如何管理類之間的關聯.當然這不僅于o/r?m有關與設計者的設計水平也有很大關系.
?2.?O/R?M對繼承關系的處理.
?3.?O/R?M對事務的支持.
?4.?O/R?M對查詢的支持.
?
以上觀點僅屬個人意見,?不過在大家討論有關O/R?m之前,?希望先就一些基本概念達成共識,?不然討論下去會越離越遠.?


(建議:?如果對oo以及dp沒有一定程度的了解,?最好別使用o/r?m,?dataset?加上codesmith或許是更好的選擇)