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     }

混沌中立 2014-06-21 23:33 发表评论

混沌中立 2009-09-02 10:53 发表评论

混沌中立 2009-08-20 13:43 发表评论

混沌中立 2006-07-13 16: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》 （敏捷软件开发：原则、模式与实践）

混沌中立 2006-06-07 10:52 发表评论

首先申明，我的帖子借鉴了网上很流行的一篇帖子，好像是来自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的影响。这一部分我还没细看，到时候再贴出来吧。

混沌中立 2006-05-30 15:30 发表评论

 

一怒之下,删除重装

 

以前因为懒,没有把插件的目录和主体的目录分开,这次也给它分开了

 

 

插件少了之后,eclipse确实快了不少

 

附eclipse启动参数: -nl en_US vmargs -Xverify:none -Xms256M -Xmx1024M -XX:PermSize=50M  -XX:+UseParallelGC

混沌中立 2006-05-30 13:48 发表评论

 

mind manager另一个比较不错的mind map的软件,可以和office兼容.不过是商业的

 

visio,就不介绍了.office里面有的东西.做流程图来说,确实是比较好的软件.但是在思路不清楚的时候,很难画出什么有用的东西来.这点就比不上前面两个东西了.不过对我来说visio可能更顺手,因为我经常画的是软件流程图........

混沌中立 2006-05-30 13:36 发表评论

 

在最近的围绕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方法。

混沌中立 2006-05-30 13:31 发表评论

混沌中立 2006-05-30 13:20 发表评论