white182517 在一个不再需要个人英雄主义的年代，程序员应该不再是苦行僧。 尊崇团队协作，关注软件工程化，快乐享受生活，这就是我的程序人生！ http://flytogether.javaeye.com UTF-8 Copyright 2003-2008, JavaEye.com http://blogs.law.harvard.edu/tech/rss JavaEye - 做最棒的软件开发交流社区 假如你突然病了或者失业了，你会怎么办？ white182517 作者: white182517  链接：http://flytogether.javaeye.com/blog/120283  发表时间: 2007年09月04日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

        今天突然接到前同事兼下属的电话，有点意外，也有一些感慨。个人觉得，在程序员这个群体，很多人对技术的关注远胜于对生活，健康和未来规划的关注。谨记下这段感想，希望所有的程序员朋友，努力工作之余，能照顾好自己的身体，炒股买房买基之余，也别忘记检查一下自己的保险是否足够。（虽然个人也觉得保险不一定能有多少用处，但是对于保障来讲，你最好别用上，这也就是他的意义所在了）。

        他是82年的，做了两年程序员，才离开一家超恶心的公司（也是我的上上家），找了一份新工作，薪水待遇都不错，职位是Team Leader，更可喜的是在新公司不久就遇到了自己心仪的人。正在他准备大展拳脚的时候，体检发现可能肝脏出了问题，要么休息，要么得住院，这就意味着新工作肯定是泡汤了。

        这个小孩是农村的，工作两年，省吃俭用争的点钱都供给两个弟弟上学和还自己大学借的贷款了，为了换工作才买了台电脑，手上几乎没什么钱了，医保也因为工作交接给停了，估计也指望不上。当初我提议他这个年纪上些住院方面的医保和大病保险比较划算（因为他比较胖，个人感觉潜在的危险会多一些），他不以为然，总觉得自己年轻，不可能那么倒霉，如果当初有上商保，这次的医疗费用应该会少很多，到现在想上也存在诈保和拒保的两难选择了。

         前一段时间，一个高中同学也是体检发现心脏有些异样，才急匆匆地问我保险的事，然后就开始戒烟。人通常都在风险来临的时候或者非得亲历痛苦的时候才会悔不当初呢？ 人生就像做项目一样，风险无处不在，特别是我们程序员，往往是透支健康来获取今天的财富，却不知道有可能你花一辈子的积蓄可能因为一次的意外而付之东流。

         当我们辛苦奔波，当我们每天面对电脑8小时以上，当我们每天抽一包烟，当我们把大部分钱都放在银行里吃利息的时候，你是否有考虑过这些风险并设计对策呢？



已有 10 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Tue, 04 Sep 2007 16:31:28 +0800 http://flytogether.javaeye.com/blog/120283 http://flytogether.javaeye.com/blog/120283 Fedora 7.0 安装中文输入法 white182517 作者: white182517  链接：http://flytogether.javaeye.com/blog/111454  发表时间: 2007年08月12日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

参考资料

www.fcitx.org/main/

www.fcitx.org/main/

下载

从www.fcitx.org 下载RPM 包：fcitx-3.2.050827-fc4.noarch.rpm

安装

执行如下命令:rpm -ivh fcitx-3.2.050827-fc4.noarch.rpm

配置

在/etc/X11/xinit/xinput.d/ 目录中创建文件fcitx,包含如下内容：

python 代码
  1. XIM=fcitx   
  2. XIM_PROGRAM=fcitx   
  3. GTK_IM_MODULE=fcitx   
  4. gnome-im-settings-daemon >/dev/null  

fcitx只能在X系统中使用，在启动fcitx之前必须关闭其他输入法，然后在命令终端输入如下命令启动：

java 代码
  1. fcitx  

如果启动失败，需要在当前用户的主目录，设置环境变量，更改.bashrc文件，添加如下几行代码：

java 代码
  1. export XMODIFIERS="@im=fcitx"  
  2. export XIM=fcitx   
  3. export XIM_PROGRAM=fcitx   

如果启动成功，输入法初始是没有激活的，需要按CTRL+空格键激活。

 



已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Sun, 12 Aug 2007 17:16:04 +0800 http://flytogether.javaeye.com/blog/111454 http://flytogether.javaeye.com/blog/111454 开发规范 white182517 作者: white182517  链接：http://flytogether.javaeye.com/blog/102849  发表时间: 2007年07月19日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

Javascript代码规范：

        Code Conventions for the JavaScript Programming Language

        Dojo的代码规范



已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Thu, 19 Jul 2007 16:21:35 +0800 http://flytogether.javaeye.com/blog/102849 http://flytogether.javaeye.com/blog/102849 了解SOAP规范 white182517 作者: white182517  链接：http://flytogether.javaeye.com/blog/75460  发表时间: 2007年04月27日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

样式/编码

        参考资料：www-128.ibm.com/developerworks/webservices/library/ws-whichwsdl/

        SOAP提供rpc和document两种样式，encoded和literal两种编码，这就组成了四种模式，还有一种document/literal wrapped模式不是规范定义的，但是得到最广泛的应用这不是规范定义的。

优缺点比较

        RPC/encoded

        优点：操作名称包含在消息中，接受者很容易基于此进行处理。

        缺点：消息中包含类型信息，增加了消息负载。无法对消息进行验证。不是WS-I兼容的。

        RPC/literal

        优点：操作名称包含在消息中，接受者很容易基于此进行处理。不包含类型信息。WS-I兼容。

        缺点：无法对消息进行验证。

        Document/encoded

        几乎不使用此模式。

        Document/literal

        优点：可以使用SCHEMA对消息进行验证，不包含类型信息。WS-I兼容（有限制）。

        缺点：消息中不包含操作名称。WSDL相对复杂。虽然WS-I兼容，但是SOAP体内容只能包含一个子元素，这会限制此模式的使用。

        Document/literal wrapped

        优点：可以使用SCHEMA对消息进行验证，不包含类型信息。WS-I兼容,消息中包含操作名称。

        缺点：WSDL更加复杂。

适用场景

        Document/literal wrapped模式是最常用的模式，但是如果同一个WSDL中需要定义两个重载操作，因为XML中不允许两个同名的元素，这种时候可以使用Document/literal。如果有两个参数相同，操作名称不同的操作，这时候用RPC/literal模式才能够区别开来。

二进制附件

       参考资料： www.ibm.com/developerworks/cn/views/webservices/tutorials.jsp

        通常有两种方式处理二进制附件，一种是将二进制流经过Base64编码后嵌入到XML文档中，一种是在XML文档中引用该数据，一个较为常见的例子是XHMTL文件中使用img标记引用图片。前一种方式会通常会增加XML文档的尺寸。

        SOAP with Attachments 规范规定二进制数据可以作为多部分 MIME 文档的的一部分发送，由 XML 数据组成第一部分，而二进制数据作为附加部分添加到其中。但是这种方式的问题在于，尽管您的程序可能知道数据存在，但文档并不知道这一点。同时，还不允许对文档进行选择性优化或对包含二进制数据的现有文档进行回溯处理。

        最近W3C制定了XOP（XML-binary Optimized Packages，XOP）协议来解决二进制问题，XOP 提供一个机制，可选择性地提取要优化的信息，将其添加到多部分 MIME 消息中（其中也包括您的 SOAP 消息）并显式地对其进行引用。

        使用 XOP 的过程称为 MTOM（SOAP 消息传输优化机制——Message Transmission Optimization Mechanism）。



已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Fri, 27 Apr 2007 12:17:13 +0800 http://flytogether.javaeye.com/blog/75460 http://flytogether.javaeye.com/blog/75460 REST样式的WEB服务 white182517 作者: white182517  链接：http://flytogether.javaeye.com/blog/75126  发表时间: 2007年04月26日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

参考资料

Building Web Services the REST Way

面向资源与面向活动的 Web 服务

Architectural Styles and the Design of Network-based Software Architectures

www.javaeye.com/topic/70113

摘要

        看了以上关于REST的资料，还是不太理解REST是个什么东东。个人觉得REST主要是一种设计的理念，架构的样式，类似于模式的东西。

        其本质是借助于HTTP协议处理基于资源访问的业务需求，主要适用的场合是针对某种类型数据的CRUD操作，通过URL来标识用户需要请求的资源。

        而基于WSDL/SOAP的WEB服务是通过规范确定了如何描述用户的请求和响应格式。      

REST主要特性

        Client-Server:基于拉式的交互方式。
        无状态: 每个请求必须包含所有必须的信息，不能利用任何服务器保存的上下文信息。
        缓存：为提高网络传输效率，响应必须能够标识为可缓存和不可缓存的。
        统一接口：基于一个统一的接口访问所有的资源如：HTTP GET,POST,PUT,DELETE。
        命名的资源集：系统由使用URL命名的资源集组成。
        分层模式：客户端和要访问的资源之间可以插入任何中间媒介，如代理服务器，缓存服务器，网关。

设计原则

        首先标识所有需要暴露为服务的概念实体。
        针对每一个资源创建一个URL，这些资源应该是名词而不是动词。
        根据客户端是否仅接受资源还是需要创建，更改资源进行分类。
        所有使用HTTP GET访问的资源，都不应该导致更改资源。
        在资源的表示中包含超链接来访问其他相关资源的信息。
        设计数据粒度，不要在单个响应文档中返回所有信息。
        使用XML SCHEMA,DTD等指定响应数据的格式。
        使用WSDL或HTML文档描述应该如何使用你的服务。

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Thu, 26 Apr 2007 16:52:09 +0800 http://flytogether.javaeye.com/blog/75126 http://flytogether.javaeye.com/blog/75126 SOAP 1.2新特性 white182517 作者: white182517  链接：http://flytogether.javaeye.com/blog/74652  发表时间: 2007年04月25日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

原文出处：www.idealliance.org/papers/xmle02/dx_xmle02/papers/02-02-02/02-02-02.html#http

摘要

SOAP 1.2发生的主要变化包括：

        SOAP 1.1基于XML 1.0，SOAP 1.2基于XML Infoset。
        SOAP 1.1和SOAP 1.2基于消息信封和编码模型的XML命名空间发生了改变。
        信封结构发生了一些变化。
        SOAP 1.1提供一个HTTP绑定框架，而SOAP 1.2提供一个抽象的绑定框架，同时提供了一个具体的HTTP绑定和一个非正式的邮件绑定。
        SOAP 1.2简化了SOAP 1.1的处理模型。
        SOAP 1.2简化了SOAP 1.1的编码模型。

体会

         本来想研读一下关于SOA相关规范，希望通过规范了解这些规范用来解决哪些问题的，主要提供哪些功能。但是这些规范全英文，晦涩难懂，看来是极难继续了。网上相关的中文资料也少得可怜。

         就用得最广泛的WSDL和SOAP规范的中文资料都相当少，可能大部分人只知道如何通过工具开发WEB SERVICE服务吧。问了一下公司几个同事，几乎没几个知道这些协议的基本信息，都没听过编码样式,绑定协议。。。。。



已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Wed, 25 Apr 2007 14:58:01 +0800 http://flytogether.javaeye.com/blog/74652 http://flytogether.javaeye.com/blog/74652 WSDL 2.0新特性 white182517 作者: white182517  链接：http://flytogether.javaeye.com/blog/73927  发表时间: 2007年04月24日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

原文出处：www.xml.com/pub/a/ws/2004/05/19/wsdl2.html

摘要

WSDL1.1到WSDL1.2的主要特性改变包括：

  1. WSDL2.0中targetNamespace属性是definitions元素的必要属性。
  2. 移除了消息构建部分，改而使用XML模式定义系统在types元素中指定。
  3. 不再支持操作重载。
  4. PortTypes重命名为接口，通过interface元素的extends属性支持接口继承。
  5. Ports重命名为endpoints。

        WSDL2.0通过两个级别来描述WEB服务，抽象级别WSDL使用接受和发送的消息来描述一个WEB服务，消息通常使用XML SCHEMA类型系统来描述，另外消息交换模式定义了消息的序列和多重性。一个接口以独立于传输协议和交换格式的方式将这些操作组织起来。

       具体级别中，使用绑定指定接口的传输协议和交换格式，服务端点将绑定和服务网络地址进行关联，而服务将针对一个接口相关的服务端点组织起来。



已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Tue, 24 Apr 2007 15:52:58 +0800 http://flytogether.javaeye.com/blog/73927 http://flytogether.javaeye.com/blog/73927 初识Lucene white182517 作者: white182517  链接：http://flytogether.javaeye.com/blog/72398  发表时间: 2007年04月19日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

前言

        目前处于工作交接阶段，比较清闲，花了几天时间看了Lucene，了解一下这个老总一直说要用之来解决项目中的问题的东东。Lucene的原理相对简单，有几篇文章很好地进行了介绍，见参考资料，这里只是按自己的理解整理一下。Lucene In Action对具体的细节有比较深入的介绍，遗憾的是该书是针对1.x版本的，新版本有很多变化，不过不影响对其原理的理解。 

        要想从海量数据中快速地查找需要的信息，比如用户想要通过Amazon查找需要的图书，最有效的方式就是建立索引，然后基于这些索引就可以快速的定位信息。  

        Lucene是一个开源的组件包，具体的应用可以基于这个组件包提供索引构建和信息搜索功能。

        使用Lucene主要包含两个步骤，一是构建索引，二是基于索引进行搜索。这两个步骤通常是两个分离的进程，最常用的作法是后台构建索引，前台提供搜索支持。

        Lucene的索引构建是基于文本文件的，如果要针对其他数据源，如数据库记录进行索引，必须进行一些预处理，Lucene本身提供对PDF,WORD等文件类型的解析器。

        构建索引的过程有一个比较关键的步骤是分词技术，Lucene发布包不提供对中文分词的支持，不过目前处于SandBox阶段有一个中文分词实现。如果要提高搜索的性能和质量，必须针对特定的应用实现自己的分词器。

实践

        写了一个简单的示例，试用了一下Lucene，基于lucene2.1.0版本，需要下载该版本的jar文件，包含在类路径即可，因为要测试中文检索，所以还需要从lucene官网下载中文的分词包。

        示例基于这样一个场景，要能很方便的根据名称查找我机器上的MP3文件，必须支持模糊查询，为了方便测试，我准备了四个mp3文件，分别是堕落天使.mp3，没你的日子.mp3，如果你还爱我.mp3，天堂.mp3。

        Mp3Searcher类主要包含两个方法，buildIndex主要用来基于上述MP3文件构建索引，目前这些索引保存在RAMDirectory中，这是一个基于内存的索引存储，运行完毕不会持久化。search方法接受一个查询字符串，返回查找结果。

java 代码
  1. public class Mp3Searcher   
  2. {   
  3.     public static final String DATA_DIR = "E:\\temp\\mp3";   
  4.   
  5.     protected static Log log = LogFactory.getLog(Mp3Searcher.class);   
  6.   
  7.     private RAMDirectory directory = null;   
  8.        
  9.     private ChineseAnalyzer analyzer = null;   
  10.   
  11.     public Mp3Searcher()   
  12.     {   
  13.         directory = new RAMDirectory();   
  14.         analyzer = new ChineseAnalyzer();   
  15.     }   
  16.   
  17.     /**  
  18.      * 查询指定歌名的结果  
  19.      *   
  20.      * @throws IOException  
  21.      * @throws ParseException   
  22.      */  
  23.     public Hits search( String name) throws IOException, ParseException   
  24.     {   
  25.         IndexSearcher searcher = new IndexSearcher(directory);   
  26.         QueryParser parser = new QueryParser("name",analyzer);   
  27.         return searcher.search(parser.parse(name));   
  28.     }   
  29.   
  30.     // 构建索引   
  31.     public void buildIndex( String dataDir) throws IOException   
  32.     {   
  33.            
  34.         IndexWriter writer = new IndexWriter(directory, analyzer, true);   
  35.   
  36.         // 遍历所有的mp3文件，添加到索引文件中   
  37.         Collection files = FileUtils.listFiles(new File(DATA_DIR),   
  38.                 new String[] { "mp3" }, false);   
  39.         if (files != null)   
  40.         {   
  41.   
  42.             Iterator iterator = files.iterator();   
  43.             Document doc = null;   
  44.             File file = null;   
  45.             while (iterator.hasNext())   
  46.             {   
  47.                 file = (File) iterator.next();   
  48.                 doc = new Document();   
  49.                 doc.add(new Field("name", FilenameUtils.getBaseName(file   
  50.                         .getAbsolutePath()), Field.Store.YES,   
  51.                         Field.Index.TOKENIZED));   
  52.                 writer.addDocument(doc);   
  53.   
  54.                 log.debug("index file " + file.getName());   
  55.             }   
  56.         }   
  57.         writer.optimize();   
  58.         writer.close();   
  59.     }   
  60.   
  61. }  

测试用例如下：

java 代码
  1. public class Mp3SearcherTest extends TestCase   
  2. {   
  3.     private Mp3Searcher searcher = new Mp3Searcher();   
  4.        
  5.     public void setUp() throws Exception   
  6.     {   
  7.         searcher.buildIndex(Mp3Searcher.DATA_DIR);   
  8.     }   
  9.        
  10.     public void testSearch() throws Exception   
  11.     {   
  12.         Hits results = searcher.search("没你的日子");   
  13.         assertEquals(1,results.length());   
  14.            
  15.         Document doc = results.doc(0);   
  16.         assertEquals("没你的日子",doc.getField("name").stringValue());   
  17.            
  18.         results = searcher.search("天");   
  19.         assertEquals(2,results.length());   
  20.            
  21.         doc = results.doc(0);   
  22.         assertNotNull(doc);      
  23.            
  24.     }   
  25. }  

总结

Lucene提供一个非常简单易用的API，可以很容易的基于其构建搜索引用，同时也提供很好的扩展。要构建一个成熟的产品级应用，还需要做很多工作，主要包括如何实现针对特定领域的分词技术来提高索引的质量，索引的大小。

如何基于数据库进行索引

        很多应用的数据都是存储在数据库中的，比如china-pub的所有的书籍目录，CMS中的客户资料。如何针对这些数据来源构建搜索应用呢？

        可以建一个后台进程，在闲时构建增量索引，比如每天晚上12点。这种方式不能保证实时查询到最新录入的数据，搜索会有一定的延迟，但是大多数这种应用都能接受这种延迟。如果要在每次增加新的数据时构建索引，会极大的影响应用的性能。

参考资料

www.ibm.com/developerworks/cn/java/j-lo-lucene1/

www.ibm.com/developerworks/cn/java/wa-lucene/

www.javaeye.com/topic/70305



已有 1 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Thu, 19 Apr 2007 10:50:48 +0800 http://flytogether.javaeye.com/blog/72398 http://flytogether.javaeye.com/blog/72398 试用JBoss Rules white182517 作者: white182517  链接：http://flytogether.javaeye.com/blog/70652  发表时间: 2007年04月13日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

前言

这两天研究了一下JBoss Rules，最大的感觉是JBoss Rules的文档写得不错，而且Eclipse IDE插件的功能也挺不错，相比JBoss JBPM好多了。

个人觉得规则引擎就是把一堆if/else逻辑从业务代码转移到配置文件中，这样如果业务规则发生变化就不用更改代码，而且如果描述这种规则的语言足够清晰明白，更改业务规则的任务就可以由业务人员来完成了，Domain Specific Language就是来干这事的。

JBoss Rules的内部机制，这里就不再详细介绍了，已经有先行者对JBoss Rules的参考手册进行了整理，参见www.blogjava.net/guangnian0412/category/11762.html。

我针对一个实际的业务场景写了一个例子，应用场景是这样的，一个汽车网的销售人员的提成有一定的规则，大致的规则根据售出价格的折扣来决定提成比例，比如如果10000元的广告服务，最后售出价格是4500，销售人员的提成是0.3%。

创建工程

假定已经安装了Eclipse JBoss Rules插件，新建一个Rules工程。

创建规则文件

创建一个规则文件如下：

ruby 代码
  1. #描述如何计算销售人员提成比例的规则    
  2. package org.gaofubing.commision   
  3.   
  4. import org.gaofubing.discount.CommisionComputer;   
  5.   
  6.   
  7. #折扣小于5折   
  8. rule "lessThanFive"  
  9.        
  10.     when  
  11.         computer:CommisionComputer(discount < 5)   
  12.     then    
  13.         computer.setDeduct(0.03);                  
  14. end  
  15.   
  16. #折扣等于5折   
  17. rule "equalsFive"  
  18.        
  19.     when  
  20.         computer:CommisionComputer(discount == 5)   
  21.     then    
  22.         computer.setDeduct(0.1);       
  23. end  
  24.   
  25. #折扣大于5折小于等于6折   
  26. rule "betweenFiveAndSix"  
  27.        
  28.     when  
  29.         computer:  CommisionComputer(discount:discount,discount > 5,discount <= 6)   
  30.     then    
  31.         computer.setDeduct(((discount.doubleValue() -5) * 0.5 + 6 * 0.1 ) / discount.doubleValue());           
  32. end  
  33.   
  34. #折扣大于6折小于等于7折   
  35. rule "betweenSixAndSeven"  
  36.        
  37.     when  
  38.         computer: CommisionComputer(discount:discount,discount > 6,discount <= 7)   
  39.     then    
  40.         computer.setDeduct(((discount.doubleValue() -6) * 0.6 + (6 - 5) * 0.5 + 5 * 0.1 ) / discount.doubleValue());       
  41. end  
  42.   
  43. #折扣大于7折小于等于8折   
  44. rule "betweenSevenAndEight"  
  45.        
  46.     when  
  47.         computer:CommisionComputer(discount:discount,discount > 7,discount <= 8)   
  48.     then    
  49.         computer.setDeduct(((discount.doubleValue() -7) * 0.65 + (7-6) * 0.6 + (6 - 5) * 0.5 + 5 * 0.1 ) / discount.doubleValue());    
  50. end  
  51.   
  52. #折扣大于8折小于等于9折   
  53. rule "betweenEightAndNine"  
  54.        
  55.     when  
  56.         computer:CommisionComputer(discount:discount,discount > 8,discount <= 9)   
  57.     then    
  58.         computer.setDeduct(((discount.doubleValue() -8) * 0.7 + (8-7) * 0.65 + (7-6) * 0.6 + (6 - 5) * 0.5 + 5 * 0.1 ) / discount.doubleValue());      
  59. end  
  60.   
  61. #折扣大于9折   
  62. rule "greaterThanNine"  
  63.        
  64.     when  
  65.         computer:CommisionComputer(discount:discount,discount > 9)    
  66.     then    
  67.         computer.setDeduct(((discount.doubleValue() -9) * 0.85 + (9-8) * 0.7 + (8-7) * 0.65 + (7-6) * 0.6 + (6 - 5) * 0.5 + 5 * 0.1 ) / discount.doubleValue());   
  68. end  

在测试的时候发生过一些问题，如果要描述折扣大于8小于9的条件，使用如下代码就不行

java 代码
  1. computer: CommisionComputer(discount:discount,discount > 6) && CommisionComputer(discount <= 7)  

另外CommisionComputer的discount属性是double类型，Rules的then部分会将其自动封箱，但是不会自动拆箱，所以如果then部分使用discount就会报错，必须使用discount.doubleValue();

创建Java类

CommisionComputer类的主要方法是computeCommision方法接受一个合同价格和售出价格，返回销售人员的提成数额。

java 代码
  1. package org.gaofubing.discount;   
  2.   
  3. import java.io.InputStreamReader;   
  4. import java.io.Reader;   
  5.   
  6. import org.apache.commons.logging.Log;   
  7. import org.apache.commons.logging.LogFactory;   
  8. import org.drools.RuleBase;   
  9. import org.drools.RuleBaseFactory;   
  10. import org.drools.WorkingMemory;   
  11. import org.drools.compiler.PackageBuilder;   
  12. import org.drools.rule.Package;   
  13.   
  14. public class CommisionComputer   
  15. {   
  16.     private static final String RULE_FILE = "discount.drl";   
  17.        
  18.     protected static Log log = LogFactory.getLog(CommisionComputer.class);   
  19.        
  20.     //折扣   
  21.     private double discount;   
  22.        
  23.     //提成比例   
  24.     private double deduct;   
  25.        
  26.     /**  
  27.      * 根据合同价格和销售价格计算销售人员提成  
  28.      * @param contractPrice 合同价格  
  29.      * @param saledPrice 销售价格  
  30.      * @return 提成  
  31.      */  
  32.     public double computeCommision(double contractPrice,double saledPrice)   
  33.     {   
  34.         try {               
  35.             //读取规则集,创建工作内存区   
  36.             RuleBase ruleBase = readRule(RULE_FILE);   
  37.             WorkingMemory workingMemory = ruleBase.newWorkingMemory();   
  38.                
  39.             log.debug("执行规则前的提成比例值为：" + getDeduct());   
  40.                
  41.             //激活规则   
  42.             setDiscount(saledPrice * 10d /contractPrice);             
  43.             workingMemory.assertObject(this);   
  44.             workingMemory.fireAllRules();    
  45.                
  46.             log.debug("执行规则后的提成比例值为：" + getDeduct());               
  47.                
  48.         } catch (Throwable t) {   
  49.             t.printStackTrace();   
  50.             log.debug("不能成功执行规则",t);   
  51.         }   
  52.         return contractPrice * getDeduct();   
  53.     }   
  54.        
  55.     /**  
  56.      * 读取规则文件  
  57.      * @param ruleFile 规则文件名称，相对于类路径  
  58.      */  
  59.     private RuleBase readRule(String ruleFile) throws Exception   
  60.     {   
  61.         //读取规则文件   
  62.         Reader source = new InputStreamReader(CommisionComputer.class.getClassLoader().getResourceAsStream(ruleFile));   
  63.            
  64.         //创建包   
  65.         PackageBuilder builder = new PackageBuilder();   
  66.         builder.addPackageFromDrl( source );   
  67.         Package pkg = builder.getPackage();   
  68.            
  69.         //构建规则集   
  70.         RuleBase ruleBase = RuleBaseFactory.newRuleBase();   
  71.         ruleBase.addPackage( pkg );   
  72.         return ruleBase;   
  73.     }   
  74.   
  75.     public double getDiscount()   
  76.     {   
  77.         return discount;   
  78.     }   
  79.   
  80.     public void setDiscount( double discount)   
  81.     {   
  82.         this.discount = discount;   
  83.     }   
  84.   
  85.     public double getDeduct()   
  86.     {   
  87.         return deduct;   
  88.     }   
  89.   
  90.     public void setDeduct( double deduct)   
  91.     {   
  92.         this.deduct = deduct;   
  93.     }   
  94.   
  95. }   

创建测试

测试代码如下：

java 代码
  1. public void testDiscountLessThanFive()   
  2. {   
  3.     double commision = computer.computeCommision(10000,4500);   
  4.     assertEquals(commision,10000*0.03);   
  5. }   
  6.   
  7. public void testDiscountEqualsFive()   
  8. {   
  9.     double commision = computer.computeCommision(10000,5000);   
  10.     assertEquals(commision,10000*0.1);   
  11. }   
  12.   
  13. public void testDiscountBetweenFiveAndSix()   
  14. {   
  15.     double commision = computer.computeCommision(10000,5500);   
  16.     double discount = 5500 * 10d /10000;   
  17.     double deduct = ((discount -5) * 0.5 + 6 * 0.1 ) /discount;   
  18.     assertEquals(commision,10000*deduct);   
  19. }   
  20.   
  21. public void testDiscountBetweenSixAndSeven()   
  22. {   
  23.     double commision = computer.computeCommision(10000,6500);   
  24.     double discount = 6500 * 10d /10000;   
  25.     double deduct = ((discount -6) * 0.6 + (6 - 5) * 0.5 + 5 * 0.1 ) /discount;   
  26.     assertEquals(commision,10000*deduct);   
  27. }   
  28.   
  29. public void testDiscountBetweenSevenAndEight()   
  30. {   
  31.     double commision = computer.computeCommision(10000,7500);   
  32.     double discount = 7500 * 10d /10000;   
  33.     double deduct = ((discount -7) * 0.65 + (7-6) * 0.6 + (6 - 5) * 0.5 + 5 * 0.1 ) /discount;   
  34.     assertEquals(commision,10000*deduct);   
  35. }   
  36.   
  37. public void testDiscountBetweenEightAndNine()   
  38. {   
  39.     double commision = computer.computeCommision(10000,8500);   
  40.     double discount = 8500 * 10d /10000;   
  41.     double deduct = ((discount -8) * 0.7 + (8-7) * 0.65 + (7-6) * 0.6 + (6 - 5) * 0.5 + 5 * 0.1 ) /discount;   
  42.     assertEquals(commision,10000*deduct);   
  43. }   
  44.   
  45. public void testDiscountGreaterThanNine()   
  46. {   
  47.     double commision = computer.computeCommision(10000,9500);   
  48.     double discount = 9500 * 10d /10000;   
  49.     double deduct = ((discount -9) * 0.85 + (9-8) * 0.7 + (8-7) * 0.65 + (7-6) * 0.6 + (6 - 5) * 0.5 + 5 * 0.1 ) /discount;   
  50.     assertEquals(commision,10000*deduct);   
  51. }  

 



已有 1 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Fri, 13 Apr 2007 15:11:57 +0800 http://flytogether.javaeye.com/blog/70652 http://flytogether.javaeye.com/blog/70652 Spring+Mysql+Jbpm整合 white182517 作者: white182517  链接：http://flytogether.javaeye.com/blog/70007  发表时间: 2007年04月11日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

前言

最近因为工作需要做一个工作流相关的DEMO，研究了一下JBPM，记录一下个人的心得与体会。

软件环境：

  • spring2.0.2
  • hibernate3.2.2
  • spring modules 0.8 (Jbpm3.1)
  • jbpm3.1.4
  • struts2.0.6

配置

Spring Module Jbpm模块提供了几个工具类用来整合spring和jbpm，关于具体的配置可以参见spring module下载包中的参考手册，按照上面的指示来就OK了，这里粘贴示例配置。

xml 代码
  1. xml version="1.0" encoding="UTF-8"?>  
  2. >  
  3. <beans default-autowire="byName" default-lazy-init="true">  
  4.     <bean id="approveWorkflow"  
  5.         class="org.springmodules.workflow.jbpm31.definition.ProcessDefinitionFactoryBean">  
  6.         <property name="definitionLocation"  
  7.             value="classpath:jbpm/audit/processdefinition.xml" />  
  8.     bean>  
  9.     <bean id="jbpmConfiguration"  
  10.         class="org.springmodules.workflow.jbpm31.LocalJbpmConfigurationFactoryBean">  
  11.         <property name="sessionFactory" ref="sessionFactory" />  
  12.         <property name="configuration" value="classpath:jbpm/jbpm.cfg.xml" />  
  13.         <property name="processDefinitions">  
  14.             <list>  
  15.                 <ref local="approveWorkflow" />  
  16.             list>  
  17.         property>  
  18.   
  19.     bean>  
  20.     <bean id="jbpmTemplate"  
  21.         class="org.springmodules.workflow.jbpm31.JbpmTemplate">  
  22.         <constructor-arg index="0" ref="jbpmConfiguration" />  
  23.         <constructor-arg index="1" ref="approveWorkflow" />  
  24.     bean>  
  25. beans>  
  26.   

比较关键的是为了能够使JBPM实体和业务实体使用同一个会话工厂，这样可以在JBPM流程实例中持久化业务实体对象。必须将业务实体映射和JBPM的实体映射进行整合。我的作法是改写JBPM本身提供的hibernate.cfg.xml文件，将业务实体包括在里面。

xml 代码
  1. xml version='1.0' encoding='utf-8'?>  
  2.   
  4.           "-//Hibernate/Hibernate Configuration DTD 3.0//EN"   
  5.           "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">  
  6.   
  7. <hibernate-configuration>  
  8.   <session-factory>     
  9.   
  10.         <property name="hibernate.cache.use_second_level_cache">  
  11.             false   
  12.         property>          
  13.         <property name="hibernate.cache.use_query_cache">  
  14.             false   
  15.         property>  
  16.         <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialectproperty>  
  17.         <property name="hibernate.show_sql">falseproperty>  
  18.         <property name="hibernate.query.factory_class">  
  19.             org.hibernate.hql.ast.ASTQueryTranslatorFactory   
  20.         property>  
  21.            
  22.            
  23.         
  24.     <mapping resource="com/emap/jbpm/model/Apply.hbm.xml"/>  
  25.   
  26.       
  27.     <mapping resource="org/jbpm/graph/action/Script.hbm.xml"/>  
  28.   
  29.     <mapping resource="org/jbpm/db/hibernate.queries.hbm.xml" />  
  30.        
  31.       
  32.     <mapping resource="org/jbpm/graph/def/ProcessDefinition.hbm.xml"/>  
  33.     <mapping resource="org/jbpm/graph/def/Node.hbm.xml"/>  
  34.     <mapping resource="org/jbpm/graph/def/Transition.hbm.xml"/>  
  35.     <mapping resource="org/jbpm/graph/def/Event.hbm.xml"/>  
  36.     <mapping resource="org/jbpm/graph/def/Action.hbm.xml"/>  
  37.     <mapping resource="org/jbpm/graph/def/SuperState.hbm.xml"/>  
  38.     <mapping resource="org/jbpm/graph/def/ExceptionHandler.hbm.xml"/>  
  39.     <mapping resource="org/jbpm/instantiation/Delegation.hbm.xml"/>  
  40.        
  41.     ........   
  42.        
  43.   session-factory>  
  44. hibernate-configuration>  

下面我们看看sessionFactory工厂的配置。

xml 代码
  1. xml version="1.0" encoding="UTF-8"?>  
  2. >  
  3. <beans default-autowire="byName" default-lazy-init="true">  
  4.   
  5.       
  6.     <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  
  7.         <property name="driverClassName" value="${jdbc.driverClassName}"/>  
  8.         <property name="url" value="${jdbc.url}"/>  
  9.         <property name="username" value="${jdbc.username}"/>  
  10.         <property name="password" value="${jdbc.password}"/>  
  11.     bean>  
  12.        
  13.       
  14.     <bean id="sessionFactory"  
  15.         class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
  16.         <property name="dataSource" ref="dataSource" />  
  17.         <property name="configLocations">  
  18.             <list>  
  19.                 <value>classpath:jbpm/hibernate.cfg.xmlvalue>  
  20.             list>  
  21.         property>  
  22.     bean>  
  23.       
  24.     <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
  25.         <property name="sessionFactory" ref="sessionFactory"/>  
  26.     bean>  
  27. beans>  

遗留问题

如何使用JBPM Process Designer插件？

       一直没找到如何使用JBPM Process Designer插件的使用文档，比如如何配置JBPM安装路径，如何部署。目前唯一用到的功能就是编写流程文件。

如何发布流程文件？

        对于如何发布流程文件，我比较同意如下帖子中的观点，编程实现或许是最简洁的方式。

www.pcdog.com/edu/java/2006/11/v171946.html

如何关联业务实体和流程实例？

        JBPM主要用来管理业务流程，记录每个流程进入哪个环节，同时还要保存一些状态，这些状态信息可能来自于业务实体。JBPM的实现方式是将这些状态信息序列化到数据库的表列。

        假定有一个订单处理的流程，现在要获取某个角色当前的所有任务列表，同时将关联的订单信息展示给用户，我们应该如何处理?目前我想到有以下几种方式：

        方式一：在构建任务实例的时候，将业务实体持久化到contextInstance，在获取任务列表时从任务实例中直接解析出业务实体。如果需要保存的业务实体数据量很大，这会给JBPM数据库造成很大的数据冗余。

        方式二：在构建任务实例的时候，仅将业务实体的唯一标识符持久到contextInstance，在获取任务列表时从任务实例中解析出任务实体的唯一标识符，然后再根据此标识符查询业务实体数据库。这种情况会造成查询一个包含N个的任务列表时，需要N+1次数据库查询，显然性能是无法满足需求的。

        方式三：是否可以在构建业务实体时，和TaskInstance进行关联？这种方式会造成业务实体和JBPM紧耦合，而且必须对JBPM本身有比较深刻的理解。

        有什么更好的办法解决这种问题呢？个人以为方式一可能是目前性价比最好的解决方式吧。

一点体会

         JBPM看来在国内并没有得到很多的应用，资料都比较稀缺，唯一的参考手册也是非常的浅显和简单。而其源码的注释不是很好，这在国外的开源软件中是很罕见的。

         JBPM提供的某些API不是很全，举个例子，假定我要查询某个角色某个时间段的所有任务列表。因为TaskMgmtSession仅提供了findXXXTaskInstances(String actorId)方法，所以我只能先查询出该角色的所有任务列表，采用如下代码：

java 代码
  1. TaskMgmtSession taskMgmtSession = context.getTaskMgmtSession();   
  2.  List tasks = taskMgmtSession.findPooledTaskInstances(actorId);  

        然后再在内存中使用类似如下代码进行过滤。

java 代码
  1. if (task.getName().equals(taskName) && !task.hasEnded())  

这种方式太笨拙和低效了。



已有 9 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Wed, 11 Apr 2007 11:53:18 +0800 http://flytogether.javaeye.com/blog/70007 http://flytogether.javaeye.com/blog/70007 Oracle相关资料 white182517 作者: white182517  链接：http://flytogether.javaeye.com/blog/66592  发表时间: 2007年03月30日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

虽然一直用oracle数据库，不过一般都局限于使用应用程序连接数据库，最近工作中接触到oracle一些深层次的东西，才发现这个很不错的网站，收藏一下!(有点孤陋寡闻啊）

ORACLE中国用户组

下面这个网页对DBMS_JOB的讲解比较透彻，相关信息在ORACLE官方文档里也有的。

www.psoug.org/reference/dbms_job.html

Supplied PL SQL Packages and Types Reference



已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Fri, 30 Mar 2007 10:39:32 +0800 http://flytogether.javaeye.com/blog/66592 http://flytogether.javaeye.com/blog/66592 数据挖掘 white182517 作者: white182517  链接：http://flytogether.javaeye.com/blog/65381  发表时间: 2007年03月25日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

概念

数据挖掘是一个利用各种分析工具在海量数据中发现模型和数据之间关系的过程，这些模型和关系可以被企业用来分析风险，进行预测。

数据挖掘是通过仔细分析大量数据来揭示有意义的新的关系，模式和趋势的过程。

现在很多公司开始采用数据挖掘技术来判断哪些是最有价值客户，电信公司使用数据挖掘检测话费欺诈行为，银行使用数据挖掘检测信用卡欺诈行为。

数据挖掘的分析数据源可以是数据仓库或者数据挖掘数据集市。

数据挖掘/CRM

数据挖掘利用数据库的信息创建模型和预测客户行为。可以用来为推销活动选择最合适的客户群，或者发现可能流失客户名单。

通过数据挖掘优化CRM流程，可以用来留住客户，提高活动的响应率。

挖掘过程 

确定挖掘对象
准备数据
建立模型
数据挖掘
结果分析
知识应用阶段

模型和算法

关联分析

关联分析是寻找数据库中数值的相关性，从大量商业数据中发现有意义的关联关系，可以帮助商业决策的制定。典型的应用如超市使用关联分析设计商品的摆放位置。

表达某一特定关联出现的频率在关联规则中称为支持度，当情况一出现时，发生情况二的概率在关联规则中称为可信度。如100万个移动用户中，有25万使用银行业务，2万用户使用手机银行和移动秘书业务，则同时使用两种业务的支持度为200/10000=2%。

Apriori算法是挖掘布尔关联规则最有影响的算法，但是其递推的过程要求多次数据库扫描，引起很大的I/O负载。

分类/预测

预测离散数据通常称为分类，预测连续数据通常称为预测。

决策树是一种典型的分类算法，可以得到类似在什么条件下会得到什么结果的规则。比如建立顾客决策树模型，进行市场细分，找出最有可能对促销宣传感兴趣的客户群。

决策树的优点是生成容易理解的规则，计算量不是很大，擅长处理非数值型数据。

聚类分析

将数据分组成多个类或簇，同一个簇中的对象之间有较高的相似度。

神经网络是常用的聚类算法。



已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Sun, 25 Mar 2007 18:23:11 +0800 http://flytogether.javaeye.com/blog/65381 http://flytogether.javaeye.com/blog/65381 好用的工具 white182517 作者: white182517  链接：http://flytogether.javaeye.com/blog/64981  发表时间: 2007年03月23日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

实用工具

一个挺不错的Html转PDF格式的工具

down.05sun.com

一个很好的思维导图工具MindManager，可以用来做会议记录，脑力激荡等等,下面有不错的教程噢

www.cuifang.com/

开发工具

一个挺不错的javascript调试工具，是Firefox浏览器的插件

addons.mozilla.org/en-US/firefox/addon/1843

.net程序员的十大必备工具

blog.csdn.net/zhumi/archive/2004/07/22/49076.aspx



已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Fri, 23 Mar 2007 15:26:20 +0800 http://flytogether.javaeye.com/blog/64981 http://flytogether.javaeye.com/blog/64981 OGNL使用手记 white182517 作者: white182517  链接：http://flytogether.javaeye.com/blog/64910  发表时间: 2007年03月23日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

基本概念 

OGNL全称是Object-Graph Navigation Language，是一个用来获取和设置JAVA对象的属性的表达式语言。通过使用表达式语法导航对象图，而不是直接调用对象的获取和设置方法可以提供许多应用。比如在XML文件或者脚本文件中嵌入OGNL表达式语法，在JSP页面展现层使用OGNL表达式语法。类似的应用有Velocity,Freemark,Webwork。

如何使用

最简单的使用是直接使用ognl.Ognl类来评估一个OGNL表达式。 Ognl类提供一些静态方法用来解析和解释OGNL表达式，最简单的示例是不使用上下文从一个对象中获取某个表达式的值，示例如下：

java 代码
  1.  import ognl.Ognl; import ognl.OgnlException;      
  2. try {           
  3.        result = Ognl.getValue(expression, root);       
  4. }    
  5. catch (OgnlException ex)    
  6. {          
  7.         // Report error or recover       
  8. }  

上述代码将基于root对象评估expression，返回结果，如果表达式有错，比如没有找到指定的属性，将抛出OgnlException。

更复杂一点的应用是使用预解析的表达式。这种方式允许评估表达式前捕获解析错误，也允许缓存解析出来的表达式进一个AST供重得使用从而提高性能。Ognl的parseExpression方法就是用来执行预解析操作的。

Ognl类的获取和设置方法大都可以接受一个context map参数，是一个Map类型的对象，允许你一些自己的变量进去，缺省的上下文里只包含#root和#context两个键。 Ognl内部会用这个Map替换OgnlContext类的缺省的map属性。Ognl的一些addDefaultContext方法就是完成这些功能的。

OgnlContext提供一些设置，可以更改OGNL的缺省行为，比如TypeConverter接口实例用来改变类型转换行为，具体可以参见相关文档。

下面的示例展示如何从root对象中解析出documentName属性，然后将当前用户名称添加到返回的结果后面：