博客园_施杨 's Think out

谈谈J2EE框架Paoding-Rose

2011-12-29T03:21:00Z

很久没有发过文章了，不是俺懒，首先是精力放到了考试和申请上了，从八月到十二月都在忙考试和申请，现在已经都

告一段落了，可以干些别的事了。其实说没时间也都是借口，主要还是技术上没有太值得写的东西，自己没亲自上手用过的，不

想写些没啥质量的水文或者评论文章，非技术的东西又写着没意思，转载某本书的章节或者翻译外文的事，俺也兴趣不大。所以

没东西写就干脆不写。

最近给我的一个产品做技术选型，耍了耍Paoding-Rose（下文简称Rose），其实这个框架早在两年前我就关注到了，

当时是在Infoq上看到的一篇人人网架构师的文章，说开源了人人网的前端框架Rose，只不过那个时候已经被各种J2EE框架整的

麻木了，所以只是下载了，但是一直没用过。当时的兴趣都在动态语言和MacOS上，那会的编译原理和操作系统课也挺牵扯精力

的（后半句是借口）。Rose的Google Code官网下载的包里没有Demo，只有几个jar文件，官网上有Wiki作为使用指南，帮助

开发者使用这个框架。Wiki写的挺全的，勤快点还是可以做出来官方Demo的。这次借这个机会，用Rose做了一个小Demo，一

个简单的雇员管理系统，包含了基本的CRUD、分页、上传、拦截器、Portal，持久层用的Rose自带的Jade，用的最新版本1.01

（其实也不算新，一年半都没更新过了），用的很舒服，开发效率非常高。如果再来个脚本工具自动建个表并生成个CRUD，那效

率就真赶上Rails了。为啥我这里要提Rails，那是因为Rails有个闪亮的特点，叫约定优于配置。（您要非说两个框架的首字母都是R

，我也没意见）。网上关于Rose的文章很少，俺写写填补一下空白吧。先声明一下，俺并没有任职于人人网，只是觉得这个开源框

架中有些设计思路不错，所以记下来。下面会谈谈我在使用Rose的过程中发现的七个明显的优点。

1. 约定优于配置

先说约定优于配置，这个优点是我体会最深的。包路径，类名，类方法名都不需要配置文件声明，只要名称包含特定的关键字和

Annotation就行，只要满足这个条件，其他的命名部分可以随便修改，不需要修改任何配置。如图：

包名和类名：

Annotation声明：

这非常爽，当年用SSH单挑项目的时候，写配置都写的手酸。这里就牵扯到XML和Annotation哪个更好的问题了，总之各有优势，

我会分场合使用。XML的优点是配置独立于代码外，无需编译，结构也更清晰直观，便于管理与修改。例如Ibatis就把sql都放到xml

里，这样确实非常方便管理。Annotation的优点就是提供一体化解决方案，不涉及XML等第三方技术标准，开发起来比较顺手也很简

洁，不用担心XML文件过多。JPA就是把数据映射都用Annotation配置，也确实干净。我在使用的过程中会把经常变动的属性提到XML

中，这样方便管理与修改。Annotation则处理不经常变动的部分，比如一些数据或路径映射关系。

2. 自动绑定

自动绑定也是非常实用的功能，Struts2和Struts比起来，比较明显的地方就是表单的自动绑定，我当时实用struts2的时候，

是必须使用struts2标签和set才能自动绑定表单数据的。Rose则不用这样，没有任何标签限制，可以自由绑定属性，并且直接通过

Annotation传参，不需要set数据。数据持久层的Jade框架也提供属性自动绑定，不需要任何的set，get方法，非常提升开发效率。

3. REST风格

由于Rose基于Spring开发，所以使用了很多Spring MVC的组件，也带来了Spring MVC的REST风格，Rose具备了Spring MVC

的很多优势，为了验证与Spring MVC的异同，我专门做了一个Spring MVC 3.0版本的CRUD操作，用来比较开发效率与实现方法。还

是Rose更为快速，Rose对Spring MVC中的URL映射和页面传值操作都进行了优化，看起来更优雅一些，完全支持REST。

4. Jade极简主义

Jade框架极大的提升了开发效率，DAO接口方法加一句SQL实现数据库操作和赋值，不多说了，上图：

补充一点，当然也是支持整合缓存框架的，即便是有些缓存框架的支持不是特别的好，我觉得自己管理缓存也无所谓，反倒更灵活一些。

自己可以决定保存哪些字段。我倒是不怎么喜欢啥都扔给hibernate管理。

5. Portal技术

这个技术蛮帅的，也是人人网架构师比较自豪的一个java后台原创技术，实现的基本原理就是对于需要许多数据渲染的页面（例如

公共主页）做页面模块切分，比如关注列表一个模块，留言一个模块，最新动态一个模块等等。然后每个模块作为一个window并发从

数据库取数据，然后再重新整合数据，最终呈现给用户。可以设置一个时限，比如几百ms，如果在限定时间内，数据没有拿出来，就不

显示这个模块了，保证用户端的响应速度。这个技术也经过了SJ圣战的洗礼，确实发挥了作用，是一个蛮有意思的设计思路。后台原理

类似scala的并发算法，把数据分块，然后并发计算。前台效果也类似新浪微博使用的页面片段加载技术，为了保证用户的响应速度，先

部分加载页面片段，逐步显示整个页面。Facebook也有一套类似的实现方案。

6. 兼容性

Rose使用过滤器而非Servlet拦截请求，现在大部分框架都在通过过滤器拦截请求，比如Struts2，Spring。这样做的好处就是，

可以方便与其他框架的兼容。也基于这点使Rose有了REST的风格。并且也可以与基于Servlet拦截请求的Struts共存，改造遗留系统。

官方描述人人网的前端框架就是这样移植的。

7. 养成好习惯

首先是灵活的拦截器控制，比如局部拦截器是基于包目录的作用域，这样可以帮助开发者养成良好的权限模块切分习惯。其次是

控制器方法映射支持正则表达式以及直接返回Json和XML格式数据，这样可以帮助开发者更好的命名映射路径与规范输出数据。约定

优于配置也帮助开发者规范的命名包和类。某种程度上Rose收集了最佳实践，引导开发者遵守规范。最后如果框架存在Bug或者兼容性

问题，可以通过修改框架源码解决。

PS：对Rose有兴趣可以访问官网，链接：http://code.google.com/p/paoding-rose/，wiki写的挺全。

我在这预祝大家元旦快乐了。I came back.

本文链接

Scala.Actor实践心得与设计思想

2011-07-29T17:21:00Z

这段时间系统的学习了Scala，编程思想上可谓收获不少，想从里面挑些值得写的东西分享给大家，Scala的Actor

可谓这门语言的一个亮点，函数式编程核心价值在于多核编程，所以就打算说说这个Actor，总结一下学习心得。先很俗

套的简单谈谈概念，然后会拿四个例子做补充。主要内容包括基本原理，设计思想，单机环境并发测试。

　　 Actor是一种基于事件的轻量级线程，在以前的并发模型中，我们需要关注共享的数据结构，而使用Actor则需要

关注操作数据的代码结构，因为减少了数据的共享。Actor的主要能力来源于消息传递，而不是采用阻塞调用的处理形式。

如果创建直接或间接扩展 Actor的类，要确保对对象的所有调用都通过消息传递进行。

我把Actor的设计思想归为两类，使用目的归为两类。从设计思想上来说Scala推荐的是以消息传递为核心的设计

思想，由于Scala可以无缝使用Java类库，所以也可以采用以共享数据为核心的设计，当然也可以写出混合式设计风格的

。使用目的主要有两种，一种是Scala提供API给Java调用，另一种就是Scala自给自足。举三个例子，例子很简单，是一

个累加器。

1、以消息传递为核心的设计：使用Actor的actor方法，使用不可变对象，不考虑数据共享问题，以消息传递为设计核心。

1 import actors._, Actor._
2 /*
3  * Author:ShiYang
4  * Blog：http://shiyangxt.cnblogs.com
5  * */
6 object SendMessageStyle {
7
8   def main(args: Array[String]): Unit = {
9     val caller = self
10     val accumulator = actor {
11       var continue = true
12       var sum = 0
13       loopWhile(continue) {
14         reactWithin(500) {
15           case number: Int => sum += number
16           case TIMEOUT =>
17             continue = false
18             caller ! sum
19         }
20       }
21     }
22     accumulator ! 1
23     accumulator ! 2
24     accumulator ! 3
25     receiveWithin(1000) {
26       case result => println("Total is " + result)
27     }
28   }
29 }

2、以共享数据为核心的设计：构建由Actor继承共享数据操作类，以共享数据为核心。

1 import actors._, Actor._
2
3 /*
4  * Author:ShiYang
5  * Blog：http://shiyangxt.cnblogs.com
6  * */
7 object SharedDataStyle {
8   case class Add(number: Int)
9   case class GetResult(sender: Actor)
10
11   class AddActor extends Actor {
12     override def act(): Unit = process(0)
13     def process(value: Int): Unit = {
14       reactWithin(500) {
15         case Add(number) => process(value + number)
16         case GetResult(a) => a ! value; process(value)
17         case _ => process(value)
18       }
19     }
20   }
21
22   def main(args: Array[String]): Unit = {
23     val addActor = new AddActor
24     addActor.start()
25     addActor ! Add(1)
26     addActor ! Add(2)
27     addActor ! Add(3)
28     addActor ! GetResult(self)
29     receiveWithin(1000) {
30       case result => println("Total is " + result)
31     }
32   }
33 }

3、以API形式提供给Java程序使用：由于Java不能直接向Actor发消息，所以需要对Scala的!()方法进行封装。

1 import actors._, Actor._
2 /*
3  * Author:ShiYang
4  * Blog：http://shiyangxt.cnblogs.com
5  * */
6 object ForJavaStyle {
7   case class Add(number: Int)
8   case class GetResult(sender: Actor)
9   private class AddActor extends Actor {
10     override def act(): Unit = process(0)
11     def process(value: Int): Unit = {
12       reactWithin(500) {
13         case Add(number) => process(value + number)
14         case GetResult(a) => a ! value; process(value)
15         case _ => process(value)
16       }
17     }
18   }
19   private val addActor = new AddActor
20   addActor.start()
21   private def add(sender: Actor, num: Int): Unit = {
22     sender ! Add(num)
23   }
24   private def getResult(sender: Actor): Int = {
25     sender ! GetResult(self)
26     receiveWithin(1000) {
27       case result: Int => result
28     }
29   }
30   def addForJava(num: Int): Unit = {
31     add(addActor, num)
32   }
33   def getResultForJava(): Int = {
34     getResult(addActor)
35   }
36 }

Java端调用代码：

1 /*
2  * Author:ShiYang
3  * Blog：http://shiyangxt.cnblogs.com
4  * */
5 public class GetFromScala {
6
7     public static void main(String[] args) {
8         ForJavaStyle$.MODULE$.addForJava(1);
9         ForJavaStyle$.MODULE$.addForJava(2);
10         ForJavaStyle$.MODULE$.addForJava(3);
11         System.out.println("Total is "
12                 + ForJavaStyle$.MODULE$.getResultForJava());
13     }
14 }

通过上面的例子可见Scala对Java语言有非常大的补充，提高了生产力。为Java提供了轻松实现多核并行编程的能

力。为了进一步测试Actor的并发性能，于是做了一个简单的单机环境并发测试。程序是构建一个Actor动态有序数组，

并发创建N个Actor对象，为了证明这些对象全都可用，顺序从数组的第一个Actor发消息到最后一个Actor，只有当一个

Actor接收到前一个Actor发送的消息后，才向后一个Actor发送消息。当最后一个数组元素接收到消息后，再把消息从数组

尾部用同样处理过程逆序发送到数组头部。这个消息发送过程不是并发处理，是顺序处理。这里只是为了证明这些对象全都

可用。如果为了测试并发处理，可以修改程序，让每个数组元素给后一位数组元素发消息。这样就会看到输出混乱的发送信

息，因为并发是无序的。

测试环境：双核4G内存，Windows XP，Sun JVM1.6，单机环境，Scala版本2.9.0.1

测试结果：当使用Receive方法接收消息时，由于Receive会在结束任务前一直持有线程，而Scala在后台默认只给Receive

方法启动256个线程，我的程序又是顺序的发消息，而且不是临时接收器（只处理一次消息），所以Receive在这种情况下，

只有255个并发。React接收器由于不需要长期持有线程，空闲即释放线程。所以React在本程序中可以跑20w的并发，如果

简单优化一下JVM，就可以达到100w的并发量。默认React接收器后台会调用4个线程组成的线程池。如果修改程序让每个数

组元素给后一位数组元素并发的发消息，那么在不阻塞线程的情况下，Receive方法也可以达到和React一样的并发量。因为

这个测试程序是顺序发送消息，所以就没有设置超时，如果是并发环境，建议加上超时，避免线程阻塞。

下面是测试程序：

1 import actors._, Actor._, java.util._
2 /*
3  * Author:ShiYang
4  * Blog：http://shiyangxt.cnblogs.com
5  * */
6 object ConcurrentTest {
7
8   val actors = new ArrayList[Actor]
9   val length = 1000000
10   var startTime = System.nanoTime
11
12   def main(args: Array[String]): Unit = {
13     for (i <- 0 to length)
14       actors.add(actor {
15         info("react: " + i + " actor created")
16         reactMessage
17       })
18     actors.get(0) ! (0, 0)
19   }
20
21   def info(msg: String) = println(msg + " received by " +
22     Thread.currentThread)
23
24   def receiveMessage {
25     var continue = true
26     while (continue) {
27       receive {
28         case (id: Int, direction: Int) =>
29           sendMessage(id: Int, direction: Int)
30         case "finish" =>
31           continue = false
32           val endTime = System.nanoTime
33           println("Finish, spend time:" +
34             (endTime - startTime) / 1000000000.0 + " secs")
35         case _ => println("input error")
36       }
37     }
38   }
39
40   def reactMessage {
41     var continue = true
42     loopWhile(continue) {
43       react {
44         case (id: Int, direction: Int) =>
45           sendMessage(id: Int, direction: Int)
46         case "finish" =>
47           continue = false
48           val endTime = System.nanoTime
49           println("Finish, spend time:" +
50             (endTime - startTime) / 1000000000.0 + " secs")
51         case _ => println("input error")
52       }
53     }
54   }
55
56   //direction=0->sendLatter;direction=1->sendFormer
57   def sendMessage(id: Int, direction: Int) {
58     if (direction == 0 && id != length) {
59       info("Actor" + id + " send message to the Actor" + (id + 1))
60       actors.get(id + 1) ! (id + 1, 0)
61     } else if (id != 0 && direction == 1) {
62       info("Actor" + id + " send message to the Actor" + (id - 1))
63       actors.get(id - 1) ! (id - 1, 1)
64     } else if (direction == 0 && id == length) {
65       actors.get(length) ! (length, 1)
66     } else if (id == 0 && direction == 1) {
67       actors.get(0) ! "finish"
68     }
69   }
70 }

前些天看到Scala正在努力支持.net平台，不过我觉得.net平台有F#，所以对于.net程序员来说Scala提供不了什么

附加价值。如果非要找出来这样做的优点的话，就是Scala可以同时支持两个主流平台，野心不小。如果看后有所收获，请

推荐让更多人看到，算我为Scala的推广尽了点绵薄之力。行文仓促，如果有不对的地方，欢迎指正。

本文链接

云计算平台实践心得

2011-06-21T07:12:00Z

有段时间没写文章了，很快就大学毕业了，放松了一段时间，大四的生活过得有些惬意，放松的太久了，重新紧起

来有些难，但是内心一直在不断的鞭策自己，今天忍不住了，决定重新开始写文章。告诉大家这个博客还要继续更新，

没有荒废掉。

这篇文章简单记录一下我的云计算平台实践，云计算这个概念，总是被不断的提起，在大三的时候就关注过一段时

间，但是当时一直停留在理论阶段，没有做什么实际的东西，所以就一直没有写任何关于云计算的东西，因为我一向是

先实践，然后总结，再写文章。大四前半段，带着我的团队把一个项目的二期开发做完，然后下半段先是考了一个烦人

的考试，然后才着手将我的云计算平台实践出来，平台的功能很少，因为只是自己做着玩，初衷是希望能够为学校实现

一个云存储平台的，统一学校的数据源，方便学校今后的网络建设和科研，为学校多做些贡献。但是学校手头也紧，公

费买个服务器都困难，只想安于现状。所以后来只能自己做着玩了，不能因为没有实际需求就不做了。

这个云存储平台是服务即平台模式的实践，提供WebService和API供其他应用系统调用，实现了20个接口，因为只

是模拟用的，数据模型做了简化，只保留核心字段。架构基于Hadoop+Hbase+EJB，大二的时候学了EJB但一直没有实

践过，一是因为没有遇到必须用这个技术的项目；二是考虑到技术门槛，不方便后面的维护。实现平台过程中遇到一个数

据节点不能为0的错误，因为报错实在是不太明确，让我一直以为是配置文件的问题，困扰了一段时间，后来发现是关于

用户权限的linux间无密码互访有问题造成的，这个问题本身简单，但是因为报错不明确，误导了我的判断。

云计算技术还在发展中，随着很多公司的采用，已经趋于成熟。任何技术都需要通过实践来发现问题解决问题。目前

来看，云存储一定程度上可以取代关系型数据库，关于数据库事务和高级查询可以借由第三方组件实现。松散的数据结构

更加利于敏捷实践，数据模型的字段可以更灵活的变更，我的云存储平台数据就是把教务系统的一些关系型数据模型过渡

到基于键值对的松散结构中的。对于一些本身就具有映射关系的字段，甚至可以简化到一个键值对关系中来。把所有关系

型数据都打散成为松散数据，确实是很颠覆传统思维的。但是有的时候逆向思维正是解决瓶颈问题的办法，比如关系型数

据库很难低成本的做到在限定时间内从几TB的数据中，排序并拿出TOP50W的数据。

Hbase本身的一些机制，可以从分布式文件存储层面就为所有数据提供缓存，对于一次写入多次读取的数据效果尤其

显著。我虽然没有看过twitter的数据层实现，但是如果让我设计，我会把最占用存储空间的数据部分，也就是一次写入多

次读取的微博和评论内容部分写入NoSQL中，稳妥起见把其他对安全性要求高的隐私数据部分写入MySQL，但是我仍然

可以把常用字段也同步到NoSQL中去以便提高系统性能。这可以看做是云存储最常见的一种实践方式。云存储的另一种常

见实践则是基于文档化的分布式存储，把视频，图片，音乐，文件以键值对的形式存储，这些媒介的共同特点都是占用空

间大，一次上传，多次读取。这两者其实可以归为一类。即使是多次写入，少量读取的数据也可以实现一个数据缓冲层，

应对频繁变更，然后定时定量持久化数据。所以存取比重不会影响对云存储的使用，因此才有了我之前把关系型数据模型

完全转化到松散型的做法。

利用Hbase本身的一些设计特点可以让我们从松散表结构设计上提高系统的性能，比如family列相同的部分会在物理上

存储在更近的节点上，所以在从关系型到松散型过渡的时候，可以把family列设置为表名，把label子列设置为属性字段，

这样同一个表的数据可以在物理上更加紧凑，便于系统更快的取出同一数据模型的相关属性。family列的定义和修改需要对

Hbase作类似于传统数据库的数据定义，而label列则不需要定义直接可以使用，通过这个特性可以使表结构字段动态化，从

而在数据持久层面实现动态化。对于功能独立的本身具有键值映射关系的属性则可以不使用上述的做法，而采用family列存

储键属性名称，label列存储键属性值，value列存储值属性的值的方法。这是松散模型设计可以采用的一种实践策略。

在业务服务层面分离成两个层，一个层作为数据操作层，负责对数据操作和事务处理，另一个层作为业务服务层，负责

业务逻辑的拼装、数据验证、身份验证等工作。接口设计方面要保证接口的合理性，清晰性，重用性。目前能想到的就是这

些了。

架构如图：

云计算实践心得介绍到这，有些朋友挺关心我接下来的计划的，在此简单说一下，俺打算毕业后先准备另一个考试，忙

完了以后找个地方工作一年，然后继续念书，因为知识越学越觉得自己会的太少，所以希望继续深造提高，谢谢朋友们的关

心，我会一直努力下去的。期待与更多喜爱技术的朋友合作与交流。

本文链接

ssh无密码登录小记

2011-03-03T15:10:00Z

最近需要用，于是随便搞了一下，本来一个道理很简单的无密码登录，让我折腾了许久，不知道

是不是ubuntu10.10的bug，我的ssh无密码登录在这个系统里无论如何就是搞不定，我尝试了root用户，和

一些不同权限的普通账户登录，也改过了.ssh和里面文件的权限，还改了sshd.conf的一些参数，又尝试改了

hosts以及不同的授权文件拷贝方法，差点有了研究一遍系统权限的冲动。最后还是没有成功，都要求输入

密码，不能无密码登录。于是一咬牙重装了ubuntu10.04,终于搞定之，让我郁闷至极，于是记录一下无密码

登录的方法。方便下次参考：

----------------------------------------------------------------

假设客户机名sy1,IP为ip1.用户名user；服务器名sy2.IP为ip2.用户名user

在sy1上输入：

ssh-keygen -t rsa

然后弹出一些问题，一路回车。然后输入：

scp ~/.ssh/id_rsa.pub user@ip2:/home/user/.ssh/ip2

输入sy2上user的密码，拷贝完成。

在sy2上，输入：

cat ~/.ssh/ip2 >> ~/.ssh/authorized_keys 
（以上步骤也可用ssh-copy-id命令：ssh-copy-id user@ip2 ,不过少了一个授权文件的备份ip2）
在ubuntu10.04里，相关文件和目录的权限都不需要改。但是会有另外一个问题就是sy2返回
Agent admitted failure to sign using the key错误，简单处理方法就是在sy1上执行两个命令：
ssh-agent  
ssh-add id_rsa 
然后就可以实现无密码登录了。
---------------------------------------------------------------- 
因为重装系统，于是再次遇到两个中文乱码问题，一道记录一下，便于以后忘了参考用。 
一个是gedit的中文乱码，一个是fcitx的中文方块，处理方法：
gedit的中文乱码：
输入gconf-editor，找到 /apps/gedit-2/preferences/encodings 节点并单击。 
双击右边的 auto_detected 键，打开“编辑键”对话框。 
单击列表右边的“添加”按钮，输入“GB18030”，单击确定按钮。 
列表的最底部新增加了一个“GB18030”。单击选中它，并单击右边的 “向上” 按钮直到 “GB18030” 位于列表的顶部为止。 
单击确定按钮，关闭配置编辑器。 
fcitx的中文方块处理：
输入：gedit ~/.fcitx/config，把显示字体（中）后的*改为WenQuanYi Bitmap Song，然后重启输入法即可。

本文链接

Mac 系统自带字典加入中文支持(2010.12.5)

2010-12-04T19:08:00Z

今天给mac的系统自带字典加入中文支持.但是网上很多的资料因为时间关系都不是完全正确, 比如

下载链接失效,或者工具版本更新造成的装载失败,不过经过一点折腾,总算是弄好了. 我用的版本是10.5.8,仅供

参考,其中DictUnifier,我用最新的2.0安装词库报错,所以我下载的是1.1版本,直接加载tar.bz2装载词库.词库我

下了几个版本都不好使,不是格式比较难看就是加载失败,于是采用了比较稳妥的词库:

stardict-21shijishuangxiangcidian-2.4.2.tar.bz2 下载地址

DictUnifier 下载地址

格式看着还可以.上图:

本文链接

{C++} COM 组件多层聚合嵌套原理

2010-12-04T07:35:00Z

大四的课还是蛮有意思的，其中有一个COM组件的课，感觉挺有收获，做了一个小Demo，是关于COM聚合的，

聚合和包容是COM的基本特征，老师上课没把这俩的关系讲清楚，也不大知道为啥放着简单的包容不用，用聚合写模块。

通过做这个Demo，俺算是理解了。因为包容只是单向调用接口，也就是从外到内，不能从内到外。而聚合则是双向调用的，

非常的灵活。下面通过具体的例子说说。

这个小Demo是控制台调用三个动态链接库的，每个链接库中都有一个方法，最外面的库CompB.dll里面是减法运算，

聚合CompC.dll里面的乘法，CompC.dll聚合CompA.dll里面的加法。CompB.dll调用接口是OtherInterface，CompC.dll

调用接口是AnyInterface，CompA.dll调用接口是SomeInterface。 CompB内部指针Inner指向CompC,CompC内部指针

Inner指向CompA，Outer指针指向CompB，CompA内部指针Outer指针指向CompC，通过这四个指针，可以使接口查询

双向传递。也就是说我可以通过OtherInterface拿到CompA的Add方法，也可以通过SomeInterface拿到CompB的Minus

方法，调用方式非常灵活。三个接口无论调用哪一个都可以访问到三个动态链接库中的所有方法。每一个方法都可以通过不同

接口调用，原理也很清晰和简单。多层聚合调用的中间层dll就需要一对指针指向上层dll和下层dll，就像CompC一样。实现也不

复杂，每个动态链接库都有一个查询接口方法，CompC和CompA通过非委托查询接口，进行调用传递。初始化过程是这样的，

CompB初始化CompC实例，CompC初始化CompA实例。CompB如果希望调用CompA就必须先初始化CompC，初始化过

程也很清晰。为了模块的灵活性，多写些代码还是值得滴。

基本原理如图：

我本地的执行输出：

多层聚合嵌套核心方法是CompC的两个查询方法：

QueryInterface:

1 HRESULT CC::QueryInterface(const IID& iid, void **ppv)
2 {
3     printf("---------------------excute CompC QueryInterface!!!\n");
4     if ( iid == IID_OtherInterface )
5     {
6         if(m_pUnknownOuter != NULL){
7             printf("CompC m_pUnknownOuter is not null!\n");
8             return m_pUnknownOuter->QueryInterface(iid, ppv);
9         }else{
10             return NondelegationQueryInterface(iid, ppv);
11         }
12     }
13     if ( iid == IID_SomeInterface ) {
14         if  ( m_pUnknownInner != NULL ){
15             printf("CompC m_pUnknownInner is not null!\n");
16             return m_pUnknownInner->QueryInterface(iid, ppv);
17         } else{
18             return NondelegationQueryInterface(iid, ppv);
19         }
20     } else {
21         return NondelegationQueryInterface(iid, ppv);
22     }
23 }

NondelegationQueryInterface：

1 HRESULT CC::NondelegationQueryInterface(const IID& iid, void **ppv)
2 {
3     printf("---------------------excute CompC NondelegationQueryInterface!!!\n");
4     if ( iid == IID_IUnknown )
5     {
6         *ppv = (INondelegatingUnknown *) this ;
7         ((IUnknown *)(*ppv))->AddRef() ;
8     } else if ( iid == IID_AnyInterface )
9     {
10         *ppv = (IAnyInterface *) this ;
11         ((IAnyInterface *)(*ppv))->AddRef() ;
12     } else if ( iid == IID_SomeInterface )
13     {
14         return m_pUnknownInner->QueryInterface(iid, ppv) ;
15     } else if ( iid == IID_OtherInterface )
16     {
17         return m_pUnknownOuter->QueryInterface(iid, ppv) ;
18     } else
19     {
20         *ppv = NULL;
21         return E_NOINTERFACE ;
22     }
23     return S_OK;
24 }

网上这方面东西不多，发篇帖子填补一下。为这方面不太清楚的同学提供下帮助。

本文链接

RVM 安装与使用帮助

2010-11-23T05:51:00Z

这个东东安装和切换ruby的版本非常方便.在这里强烈推荐一下.Mac系统自带的ruby版本比较陈旧.所以俺需要一个工具来管理,RVM的安装

需要借助bash和git,这两个工具安装很简单,不多做介绍了.

安装RVM命令:

bash < <( curl http://rvm.beginrescueend.com/releases/rvm-install-head )

然后修改用户配置文件/Users/username/.profile,你也可以写到别的全局配置里.

添加一行代码:

[[ -s "$HOME/.rvm/scripts/rvm" ]] && . "$HOME/.rvm/scripts/rvm" # This loads RVM into a shell session.

重启Terminal,RVM就安装好了. RVM的使用过程中不需要使用sudo,gem也不需要.

然后就可以安装ruby了,例如:

rvm install ruby-1.8.7 --head --docs

--docs是编译安装后自动生成文档，--head是最新的版本

删除某个版本的ruby，并且把文档和gems都删除,则:

rvm remove ruby-1.8.7 --docs --gems

选择版本:

rvm use ruby-1.8.7 --default

查询当前版本:

rvm info

列出版本:

rvm list

更多命令,访问 http://rvm.beginrescueend.com/rvm/

本文链接

俺只是个穷学生...培训企业诚与不诚请勿扰

2010-11-12T15:06:00Z

哎,这个社会什么公司都有,但是基本都发扬着榨干员工最后一滴血的高尚情操,能多抠多抠,能多剥削多剥削.IT类企业尤甚.

能花500找个学生干的,绝不花3000找个社会上的.能花个3000找个码工干的,绝不花10000找个高级程序员做,即使写出的代码

难以维护,超烂,超多漏洞,只要功能过得去一切都好商量.

这些公司一般也就是些无名公司,但是没想到有些名气的公司,也搞这套.前两天一个公司来我校招人,俺觉得这个公司挺有

名的,也看好这个公司的前景,毕竟国内没多少人在做他们那块.缺少竞争对手.所以俺就想去瞅瞅,仰慕一下,也试试自己的水平.后

来了解之后挺出乎意料的:

他们招的人并不是直接进北京总部,而是留在本学校培训,交10000块培训费,签1年的合同.顺便帮他们做做外包.前三个月

没钱拿,第四个月开始月薪1500,但是考虑到学生没那么多钱,可以先交3000,然后公资抵消一下剩下的7000,基本一年都白干了.

说得那么啰唆,无非就是白干1年,还要交3000.不过如果只是说这些,当然没啥吸引力,然后又给你描绘培训后你的未来会很光明滴,

很多大公司抢着要滴.俺觉得这种小几两还是留着逗小孩吧.

但是俺本来也对早些进公司被剥削没啥欲望.不过毕竟是个"大公司",俺还是决定参加面试,长长见识,没料到后来更可笑,说是

技术总监面试,后来来了个和我同届的女学生做面试官.而且还迟到了,俺觉得也太不专业了.面试(人家说是聊天)没问出个啥,俺好好的

"表现"了一下,本来打算给他们的软件提提建议的,做得确实切入点不够准确,后来人家说不方便聊产品,俺就算了.

这就是故事的经过.不过这个公司当时还口口声声说不是培训公司,说什么就是招聘.在这里俺想告诉他一件事:

作为一个正规企业招聘,即使员工不能马上上手,入职培训或者找个人带着都应该是免费的,企业安排的培训对于员工来说算是

一种福利,而不是企业赚员工钱的理由.只要是培训收钱的,都是培训公司.这就是培训公司和招聘公司的区别.不用谢,我白教你这个概

念滴,不要钱.

这时可能你又要反驳我了,说我们是为了企业的利益着想,如果白教给了你,你学会了跑了,那我们岂不是损失很大.我想说的是那是

你们的问题,你们根本就不该把素质那么低的人招进你们公司.那是你们看错了人,OK?有的时候不是有能力就一定有品德,你们招聘的

时候麻烦看清楚.

承认你们是培训公司了不?不承认?,你还可以反驳我说"我们让你们做外包,并没有让你们做玩具项目."这你就更Caodanlity了,找

在校生给你们做外包, 你们还真会节约成本.学生交给你3000,白给你做1年外包,开玩笑.我们又不是没有公司可去.唯一值得让我肯定一下

你们的就是,你们对我的水平比较认可.说不用3个月,学1个月就能上手开发外包,俺真是谢谢您. 但是待遇一样,交3000,白干1年.

说的够多了,俺该洗洗睡了.

俺是穷学生,买不起Mac,只能黑一个,莫鄙视俺,一般俺不进这个系统,因为驱动不够完美.(本本跑了4个系统,win7也不用),今天重新耍耍

Xcode:

PS:<"老男孩"这个电影还是不错滴>

PS:最近听了GD的音乐,很潮,很有才.欣赏,但是不哈韩.

本文链接

编译原理实验总结及实现分析递归下降与算符优先原理

2010-05-13T04:18:00Z

这篇文章本来不打算写了。但是后来还是决定写一下。写这篇文章的目的，是帮助大家了

解到编译原理语法分析的模拟实现过程，因为我身边的一些同学，对这后两个实验没什么思路，所以

就引发了写作此文的冲动。

-----------------------先上图------------------------

使用说明：

词法分析：

语法分析：

词法分析大部分同学没什么问题，所以就不写原理了。

下面简述后两个实验的代码实现分析：

递归下降：

把接收的输入字符串，转化成字符数组。过滤非法字符，如果输入非法则报错，如果是合法字符，则进行递归分析，先传入加减处理

函数，然后转入乘除处理函数，乘除处理函数则将方法传递给括号处理函数。如果包含括号，则判断是否后一位是数字，如果是就进行数字分

词，取出数字串转换成十进制，然后赋值给临时变量。如果不是则返回错误。返回计算结果临时变量给乘除方法，乘除方法判断是否包含乘除

符号，如果包含，则转入括号处理函数做分词，然后对返回的临时变量做乘除运算，如果除数为0，则报错。返回计算结果到加减处理函数，

然后验证一下程序此时是否有错，如果没错，进行加减判断，如果包含加减符号则传入乘除处理函数处理，然后把计算结果传给加减函数对临时

变量做加减操作。并返回最终结果。

算符优先：

把输入字符串转换成字符数组，同时新建一个临时数组保存中间结果，遍历数组，进行字符类型检查，如果不符合，则报错。如果符

合，执行移进归约判断，根据临时数组当前索引的值，调整索引位置，然后取出临时数组的字符，查表取出横坐标的值，然后根据当前输入字

符查表取出纵坐标的值，然后根据获得的横纵坐标查算符优先表，获得字符优先关系，根据关系判断递进、归约和结束。如果归约则判断当前

临时数组索引的字符是否是合法字符，如果不是则调整索引。然后在根据临时数组取出算符优先表里的横纵坐标，然后根据算符优先关系，经

过判断，确定输出到界面的格式，并输出。然后再次判断移进还是归约，重复以上步骤，如果需要移进或者结束，则直接获取坐标，取得算符

优先关系，如果关系为移进，则执行移进输出，如果关系为结束则输出接受。如果都不属于则报错。返回处理入口，取下一个输入字符，再次

判断。

代码就不贴了，不要养成copy代码的坏习惯。我已经尽力描述了我的实现，如果有不对的地方，可以指出来。

有些人的机子分辨率低，页面会有些变形，因为图片可能有点宽。

最初不想发到首页，但是发现其他地方的帖子看者寥寥，所以我也希望得到更多高人的指点，只有交流才能进步。如果管理员觉得不合适可以

移除。

本文链接

一个Java小程序的跨平台思考

2010-05-04T06:10:00Z

最近做了一个小的编译原理作业，是一个C_minus语言的词法分析器，本来四月初就已经写好了一个版本，而且

支持一部分的语义逻辑验证，并且还可以处理所有常数，所有的关键字，所有的算术运算符，因为功能超出了老师的预期，

以至于被老师怀疑是抄袭网上的代码，当然老师不只怀疑我，也怀疑别人。最终凭借我的讲解，彻底让老师信服。但是由于

我考虑到一个方法的可读性原则，不想一个循环把所有逻辑都处理掉，所以写了多个处理方法，把一个大循环，分离成多个

子循环。这样可读性上升了不止一个档次。但是老师还是坚持要我们能够一个几百行的循环把所有逻辑都覆盖了。所以俺只

有重新写了，但是由于前段时间比较忙，直到这会儿，才有空把这个作业完成。

不管是刚接触Java的，还是Java学的半生不熟但说自己很牛的，都知道Java有个特性就是跨平台。俺就拿这个程序做

了一把验证。这个程序是带UI的，UI用的是Swing。但是Swing不像我希望的那样表现的那么出色。在相同jdk版本的情况下，

兼容Linux良好，但是Mac里表现的就不尽如人意了。界面变形很厉害。于是把代码小改了一下，把Area改窄了。于是可以跨

平台了。但还是做不到零修改。我这还算是比较简单的程序，UI很简单，但是如果是个比较复杂的swing做的C/S软件，那估

计就不会这么幸运了。而且Java这块打安装包的工具也很少，顺手的并不多。我用的那个软件在Linux和mac在打包的过程中，

不绑定jre，这也让Java桌面应用跨平台蒙上了一层阴影。希望这方面有经验的朋友给推荐个比较好的打包工具。

目前Java的应用领域已经完全倾向webApp和mobileApp。如果桌面还想分的一杯羹的话，建议Oracle能出个强

大些jre打包软件（最好免费，不过不大现实）。或者出个兼容性好些的GUI框架，jre的版本之间的差别相信大家也深有体

会，而且一般打包后体积也大很多。下面上几个截图：

Linux平台：

Mac平台：

XP下：

Mac平台词法分析软件下载连接（不含jre，mac下会自带jvm，但是往往版本较老，10.5.*一般是1.5的，这个安装包我已经测

试，可以完美运行在JVM1.6下，有兴趣的朋友可以装装试试）:

点击下载

本文链接

博客园_施杨 's Think out

谈谈J2EE框架Paoding-Rose

Scala.Actor实践心得与设计思想

云计算平台实践心得

ssh无密码登录小记

Mac 系统自带字典加入中文支持(2010.12.5)

{C++} COM 组件多层聚合嵌套原理

RVM 安装与使用帮助

俺只是个穷学生...培训企业诚与不诚请勿扰

编译原理 实验总结及实现分析 递归下降与算符优先原理

一个Java小程序的跨平台思考

编译原理实验总结及实现分析递归下降与算符优先原理