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

通过一周左右的研究，对规则引擎有了一定的了解。现在写点东西跟大家一起交流，本文主要针对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或许是更好的选择)