一个月以来都没写博客，这篇博客的目的是提醒自己继续写下去，顺便记下笔记，看官若无兴趣请直接飘过。

级联表是关系数据库存储领域模型（Domain Model）中一对多关系的不二法门，比如“学生”和“班级”，实在是常用得很。创建表时建立外键关联，查询时使用inner join或者多表联合查询非常便捷。不过插入数据则相对麻烦，因为关键关联的缘故，需要先插入主表，然后再插入从表，如果使用auto_increment主键，在插入从表之前必须获取刚刚插入主表时生成的ID。

举例来说，下面classes和students表通过外键class_id建立一对多关联：

DROP TABLE IF EXISTS students;
DROP TABLE IF EXISTS classes;
DROP VIEW IF EXISTS student_in_class;
 
CREATE TABLE classes(
  id serial,
  name CHAR(55) NOT NULL,
  UNIQUE KEY cls_name (name),
  PRIMARY KEY(id)
);
 
CREATE TABLE students(
  NUMBER CHAR(11) NOT NULL,
  name VARCHAR(55) NOT NULL,
  class_id BIGINT UNSIGNED NOT NULL,
  PRIMARY KEY(NUMBER),
  FOREIGN KEY (class_id) REFERENCES classes(id)
);

为了查询数据方便，创建一个视图，只是简单的执行级联查询：

CREATE VIEW student_in_class AS
SELECT NUMBER, students.name stu_name, classes.name cls_name 
FROM students
INNER JOIN classes
ON classes.id=students.class_id;

对于之前提出的两个表同时插入数据的问题，熟悉MySQL的朋友都知道，用下面的方法就行了，先插入主表classes，然后通过last_insert_id()获取刚刚插入的id，最后向从表students插入数据。

START TRANSACTION;
INSERT INTO classes(name) VALUE('Class 1');
INSERT INTO students(NUMBER, name, class_id) 
  VALUES('001', 'Jim', last_insert_id());
commit;

不过这样还是有个问题，如果待插入的数据和主表中已有的数据有重复怎么办呢？因此笔者对以上语句进行简单的封装，使用MySQL存储过程实现整个过程，首先对主表进行查询，如果不存在待插入的数据再插入：

DROP PROCEDURE IF EXISTS insert_stu;
CREATE PROCEDURE insert_stu(
  cls_name CHAR(55), 
  stu_num CHAR(11), 
  stu_name VARCHAR(55))
BEGIN 
  DECLARE cls_id BIGINT UNSIGNED;
  DECLARE cls_cnt INT;
  SELECT COUNT(*) INTO cls_cnt FROM classes WHERE name=cls_name;
  IF cls_cnt = 0 THEN
    INSERT INTO classes(name) VALUE(cls_name);
    SET cls_id = last_insert_id();
  ELSE
    SELECT id INTO cls_id FROM classes WHERE name=cls_name;
  END IF;
 
  INSERT INTO students(NUMBER, name, class_id) 
    VALUES(stu_num, stu_name, cls_id);
END;

调用和检验该存储过程的方法如下：

CALL insert_stu('Class 1', '001', 'Bob');
CALL insert_stu('Class 2', '002', 'Jim');
CALL insert_stu('Class 1', '003', 'Li Lei');
 
SELECT * FROM student_in_class;

最后一句是使用之前创建的视图查看输出结果：

number  stu_name  cls_name
001        Bob          Class 1
002        Jim           Class 2
003        Li Lei        Class 1

参考：

1. Stackoverflow: Is it possible to insert into two tables at the same time?
2. http://dev.mysql.com/doc/refman/5.0/en/create-procedure.html
3. MySQL transaction commit
4. MySQL last_insert_id() function
5. MySQL If statement

diff程序是linux上非常重要的工具，用于比较文件的内容，特别是比较两个版本不同的文件(本文中的a.c、b.c可以理解为两个版本的同一个文件，b.c是在a.c的基础上的修正版)以找到改动的地方。diff在命令行中打印每一个行的改动。最新版本的diff还支持二进制文件。diff程序的输出被称为补丁(patch)，因为unix系统中还有一个patch程序，可以根据diff的输出将a.c的文件内容更新为b.c。diff是svn、cvs、git等版本控制工具不可或缺的一部分。

diff和patch实例

下面用一个实例来讲述diff和patch的使用。
文件a.c的内容如下：

#include <stdio.h>
 
int main(int argc, char *argv[])
{
    // add code here
    return 0;
}

文件b.c的内容如下:

#include <stdio.h>
 
int main(int argc, char *argv[])
{
    printf("Hello world");
    return 0;
}

执行命令：

diff a.c b.c > b.patch

输出b.patch的内容如下：

5c5
<     // add code here 
--- 
>     printf("Hello world");

接着执行下面的命令就可以将patch文件b.patch应用于a.c文件上，将a.c文件的内容更新为新的版本(即b.c)

patch a.c b.patch

a.c的内容被更新为b.c的内容：

#include <stdio.h>
 
int main(int argc, char *argv[])
{
    printf("Hello world");
    return 0;
}

不过，diff的输出让人读起来很废劲，因为这个输出本来就不是给人看的，如果你知道一点关于ed编辑器的用法，就容易理解了。最开始的时候diff的输出不是这种格式的，后来受到ed编辑器的影响才变成这个样子，至于其发展历程请移步维基百科，因此在解释diff的输出之前，先简单介绍一下ed编辑器。

ed编辑器

ed是一个交互式的文本编辑器，类Unix系统中有很多很神奇的编辑器，号称神器的有vi、vim、emacs，还有常规意义的编辑器nano、gedit，还有看起来很诡异的sed(Stream Editor)、awk，ed这是另一个很诡异的编辑器，不同于前面的任何一种。

打开shell，按次序输入如下的命令(需要一句一句的敲)：

touch c.c
ed c.c
0a
#include <stdio.h>
int main(int argc, char *argv[])
{
    // add code here
    return 0;
}
.
w
q

使用cat命令查看c.c，该文件的内容就是上面代码中“0a”和“.”之前代码。

和vim一样，ed通过一系列的命令来编辑文件：

• “ed c.c”表示用ed对文件c.c进行编辑
• “0a”表示在第0行后进行添加(a表示add，同样，d表示删除，c表示修改)
• 接着输入需要添加的内容，输入完成后换一行，输入“.<CR>”(<CR>表示回车)，表示输入完成
• 输入“w<CR>”表示保存文件
• 输入“q<CR>”表示退出编辑器

ed编辑器的好处在于可以将一系列命令写成一个文件，然后进行批量执行。比如需要在所有的源代码开头加上版权信息，则可以编写如下的ed文件，保存为add_header:

0a
/**
 * © 2012 zhlwish.com
 */
.
w
q

然后写一段shell脚本对源代码文件进行遍历，对每个代码执行如下代码即可批量对源代码文件添加版权信息：

ed a.c < add_header

关于ed的命令和其他方法请参考Unix ed Editor Command Set本文不详述。

diff的输出

diff的输出格式是对ed脚本(ed script)的一种扩展，遵循ed的命令语法，添加了”<”和”>”分别用于表示新文件的内容和旧文件的内容，比如前文中diff的输出可以按如下方式理解：

• “5c5”表示a.c的第5行有改动(change)，改动后为b.c的第5行
• “< // add code here”表示a.c的第5行的内容
• “— ”是分隔符
• “> printf(“Hello world”);”表示b.c文件的第5行的内容

当然还有更复杂的情况，如“3c3,6”、“6d8”，前者表示旧版本文件中的第3行被修改，对应新文件中的第3-6行，后者表示旧版本文件的第6行被删除，在新文件中是第8行。

可以通过参数指定diff输出格式，有兴趣的笔者可以分别进行尝试：

• -e –ed 输出为ed命令格式
• -n –rcs 输出为rcs命令格式
• -y 输出为两列对照模式
• -c 输出为上下文模式

diff的选项

除以上选项外，diff的有用的选项还包括：

• -r：当diff的参数为文件夹时，diff会遍历整个文件夹对新旧文件夹下同名的文件进行比较
• -w：忽略所有空格和制表符，将所有其他空白字符串视为一致。例如，if ( a == b ) 与 if(a==b) 相等。
• -i：忽略字母大小写。例如，小写 a 被认为同大写 A 一样。

因为成文仓促，不免有不对之处，敬请读者指正。(全文完)

参考资料

• Linux命令diff
• Sed学习笔记
• Editing files with the ed text editor from scripts
• Unix ed Editor Command Set
• Hello World” with ed editor(Youtube)
• 用Diff和Patch工具维护源码

该视频来自于2011年9月12日举办的理想国文化沙龙，文字稿来源于优米网，本人有部分修正。

视频

文字稿

今天这个现场满有意思的，也许同学们都知道隔壁就是东交民巷，八国联军来的时候早期的国民党往那逃。马路对过是北京火车站，张作霖进入北京就是在那下车，李鸿章进入北京，然后，1949年毛泽东带着文武官员到火车站迎接宋庆龄从上海到北京，就在马路对过，现在那个火车站废弃不用了，但建筑还在。再往西一点就是大前门，我看过一张蛮珍贵的照片，1948年北平已经被包围了，不知道从什么角度拍过去，当时天安门广场是荒草场，但是大前门挂了一张蒋中正的巨大的照片，据说解放军进城以后弄开国大典，先前的选择不是在天安门广场而是大前门，因为整个军队入城的仪式是由南向北，经过现在的天桥往北走，后来不知道怎样改成天安门，所以我们小时候有一首歌叫“我爱北京天安门”，如果当时选了大前门就是“我爱北京大前门”。这个地方据我知道是民国时期美国驻中国领事馆，司徒雷登就在那上班吗？毛泽东有一篇很重要的文章“别了，司徒雷登”，意思是咱们到此为止，所以司徒雷登当时就在我们上面。不过我今天进来的时候军警林立，我才意识到这是靠天安门的地方。

我觉得“民国是历史的还是现实”是一个好话题，但是如果记者问我，我会答不上来，因为现实和历史这两个词不能定义，可能指过去已经不在场或者不奏效的就叫历史。而现实还在，还有作用，还在发生，可能就是现实。讲下去就会有点错位。我记得1966年文革爆发，毛泽东狠狠的对全党和全国人民说，无产阶级文化大革命是革命派和反革命、共产党和国民党的继续斗争。那一年我13岁，戴着红领巾，而且共和国也已经17岁了，我听了毛泽东这么一番话心惊肉跳，我想怎么民国还没有过去，国民党还在？这是我小时候的印象。现在我明白毛泽东其实没有错，他那一年70多岁，除了逃到台湾的那部分国民党，他的许多民国朋友和敌人都还活着，曾经顶撞过他的梁漱溟，曾经杀过共产党的李济深都住在北京，一大群民主人士、第三势力，还有他的同志们。而毛泽东本人，包括周恩来、朱德等共产党领导人曾经就是国民党员，在国民政府做官，当着蒋介石的面喊“蒋委员长万岁”。所以毛泽东想起民国和我当时13岁的小孩听见的民国感觉是不一样的，他一想起就是一大群使他不安的活人。

1976文革结束至今35年，远远超过毛泽东回想民国的时间距离，我们或者可以问文革是历史还是现实。30多年来我们的文人和出版社都在做历史研究，出历史书，在座诸位也想必喜欢读历史。读历史为了什么？克罗齐说的还没过时，所有的历史都是当代史。今年算是借辛亥百年，我们有理由在市面上公开说民国，为了尊敬今年另一个大的纪念，我特地到钻到电影院看了《建党伟业》，看完以后手机来了几条短信，其中有一条非常聪明，把建党和民国一块纪念了，大家可能读过这个短信，我再念一遍：《建党伟业》是一部向北洋军阀政府致敬的电影，该片用生动的镜头、精彩的案例、温馨的细节为我们描述这样一个时代：报纸可以私人控股，新闻可以批评政府，大学可以学术独立，学生可以上街游行，群众可以秘密结社，警察不可随便抓人，权力有边界，法律有作用，人权有保障，穷人有活路，青年有理想。我不知道这个手机短信作者是谁，大家为他鼓掌。总之这部电影拍着不小心把民国史拍出来，我猜韩三平没有想到这效果。虽然这条短信谈到历史又明明指向现实，简直已经回答了论坛的话题，但是我不能念一条短信交差，所以赶紧清理我可怜的历史知识，看看民国哪些往事已经过去了，算是历史，哪些往事还在，算是现实。

先说成为历史的那个民国。首先民国的战乱过去了，我们几代人何等幸福，60年来没有遭遇任何外敌侵略。文革的武斗当然是毛泽东所说的继续斗争，但是死伤者者没有一个是国民党员，而是和在座一样年轻的男女。昨天听秦晖先生说起广西的武斗，他看到高射炮平射和在越南用的炸药弹。当时他十几岁，武斗过后清理现场，巨大的瓦砾堆，只要闻到臭味就可以掘起一具尸体，但这个跟民国战争不能比。

其次半殖民地时代过去了，帝国主义在中国的殖民区域完全消失，虽然现在上海、武汉、南京、天津等市政府竭力刷新英租界、法租界所有好地段为旅游业赚大钱，但是像康有为、梁启超、胡适、鲁迅这样的闯祸胚子再想闹事没有地方躲了，即便赖昌星逃到加拿大还是回来戴手铐。

再其次，中国分裂的时代过去了，民国时期或者先后或者同期，有过南京政府、武汉政府、瑞金苏维埃政府，有过延安政府，有过重庆政府，还有过满洲国。东北的满洲国有东三省的铁路网，忽然归张作霖管，忽然归日本人管，忽然归苏联人管。今天全国的铁路畅通无阻，新建的铁路线和载客量是民国时期的几十、上百倍，虽然最近发生动车追尾暴死几十个人，但成绩绝对是主要的。你们不相信吗？反正我是相信。

再再其次，国家的弱势完全过去了，民国政府根本没有象样的空军和海军，要靠美国人和苏联人帮忙，后来匆忙培养自己的空军飞行员，在对日保卫国家的空战中几乎全部死光。我们的空军非常棒，都活着，还驾驶飞船进入太空，当然我们自己的航空母舰马上要问世了。

此外，民国的多党政治彻底过去了，但这个是敏感的问题，我不敢说。我敢说的是民国教育的黄金时代完全过去了。蔡元培的北大、梅贻琦的清华、张伯苓的南开、竺可桢的浙大绝对成为历史，一去不复返。现在他们想当校长，先得通过层层审查，接着慢慢混到正局级或者副部级才能填写申请表听后审查。另外蔡元培为陈独秀假造学历，梁启超延聘没有学位的陈寅恪再也不能得逞了。

民国出版的自由和言论自由也过去了，像张元济、王云五这样的出版大亨再也不必辛辛苦苦自己开办商务印书馆之类，邵飘萍、史量才这样的亡命记者和报业大王再也不会被枪毙被暗杀。当今中国的出版商、记者、撰稿人一律享受新闻出版总署的保护，非常安全、非常正确、非常和谐，所有人都很乖，很懂事，绝对不怕被枪毙。

最后一个可能被忽略的巨大事项也成为历史，那就是古文教育，文言文和白话文并存，繁体字等等构成的汉语语言生态成为历史了。在民国所有识字的人既懂文言也懂白话，既用繁体字也用当时通行的简体字，随着民国的消亡，汉语的生态永远消亡了，我们当世只有白话文，只有简体字。

民国许多其他事都成为历史，永远过去，一部分是历史进程本身，比如现代化。一部分是政治原因，比如无所不在的禁止。但限于发言时间不能一一例举，现在我来快速例举民国仍在今天奏效的部分现实。比如，据说民国的灭亡原因主要是贪污腐化裙带关系，今天所有被指控的民国腐败者远远无法和共和国贪官比。从资料披露，一向被认为巨贪的宋子文不但没有怎么贪污，而且是强硬的民族主义者。就算他财富不很清楚，但和今天随便哪个被揭露的地方贪官相比，简直羞煞人。当年为蒋介石负责运送黄金到台湾的一位老先生，我忘了他的名字，我在三联周刊看过他的报道，没有贪污过一分钱，死了以后他的存折拿出来只有8万美金。至于裙带关系不用我来说，今日权利格局的血缘背景，一点不比民国时期更薄，如果需要证据，我希望学者做统计。民国社会层面世俗生活的状况一度被铲除，之后20多年大规模卷土重来，比如色情业，比如赌博、走私、黑社会，都在渐渐与民国接轨。

此外改革开放30年，凡私人生活逐渐被允许拓展的空间，都是民国生活形态的死灰复燃。比如选美、时尚、娱乐、交际、享受、奢侈等等，这些都是好消息，大家不要以为这是我们今天时代的稀罕事情，民国时期早就有了。这种活泼可喜的生活形态，有的远远比民国时期土，因为有教养的阶层消失了，有的远远比民国更洋，因为民国人还没机会领教西方二次现代化以后的种种新花样。

时间关系，以上关于历史与现实的类比十分粗糙，不准确、不可靠，希望专家批评指教。但是坦白说，我以为民国对于今天，对于大部分年轻人，既不是历史，也不是现实，为什么？

因为60年来我们接受了空前成功的愚民教育，这种教育的核心就是不要让你知道过去，直到你对过去漠不关心。现在绝大部分中国人，尤其是年轻人，没有历史感，没有现实感，对共和国不了解，更不了解民国。30年前邓小平说国著名的话，体育要从娃娃抓起。其实真正要紧的是历史要从娃娃抓起。

最近听说秦晖请大学生自己做调查，题目叫你最熟悉的陌生人。请今天的80后、90后向父母或者祖父母追问民国的往事，这是了解民国最最有效、最最人性的方式，因为民国就在每个家庭。刚才马世芳说了他的家庭，我们大陆有很多这样的家庭，我的父母就是民国人，诸位祖父母也是民国人。据说问到一半，就有家长出来阻拦，不要再问了，也不愿再说。为什么？就是害怕历史提醒现实，因为今天的现实害怕历史，以致历史也害怕今天。因为民国的历史就是活人，所有民国的过来人迫于现实回避历史，不谈历史，这就是我们今天普遍的现实。所以最熟悉的陌生人是个好题目，你是爹妈生出来的，你不了解爹妈，中华人民共和国是民国生出来，可是共和国的老百姓不了解民国。长期不了解、不说就不会想了解，不想说；长期的不说几代人不说，等于没有这回事。比如80后，比如89年出生的孩子，别说1949年前的民国，连1989年北京发生什么事绝大部分不知道。我们的爹妈也未必知道，你们在北京的爹妈可能知道，但是他们不愿说。这样不说、不说，每个家庭都对孩子瞒着往事，整个国家对人民也瞒着往事，瞒得久了，30年、60年瞒下来，将来还会瞒下去。你现在到马路上抓一个小青年问他你要不要听民国，他掉头就走，根本没有兴趣。所以我觉得民国既不是历史，也不是现实。但是今天在座的年轻人比较不一样，大好秋天哪里不能去，你们要跑到这里来听民国，什么意思呢？但是你们还是来了。谢谢大家。

最近耶鲁大学和北京大学的宣传片对比在微博上很火，对北大也是骂声一片，毕竟人们对北大的期望要更高些。耶鲁大学的宣传片很运动、很活力、很激情，看完顿感身上有了活力。北大的让人感觉很艺术，但是也很假，不过毕竟相比以往的宣传片有很大的进步。然后，我就找了咱华中科技大学的宣传片，有老版和新版，新版应该是5年以内拍的，顿感差距啊。今年是华中科技大学60年校庆，应该会有新的宣传片出炉，期望有所进步吧。

耶鲁大学《Why I choose Yale》

北京大学宣传片

华中科技大学宣传片（老版）

华中科技大学宣传片（新版）

一直用VMware Workstaion上安装Linux虚拟机进行开发的，安装软件等比Windows上方便很多，因为部署环境也是Linux，因此也避免了编码、换行符等平台兼容的问题，在Linux虚拟机中安装Samba解决文件系统共享的问题，一直都相安无事。

最近为电脑重装了XP，安装好VMware Workstation 7后运行以前的ArchLinux的虚拟机，从发现samba连接不上了，可以在网络邻居的工作组中找到Linux虚拟机，但是共享无法连接，连登录的对话框都不显示。没办法，尝试安装vsftpd，用FTP来共享文件，结果FTP也无法连接，FTP显示已经建立连接，然后就没反应了。后来发现ssh也无法连接，经检查，网络连接正常，也没有安装iptables防火墙，更没有Selinux。并且在同局域网内的其他电脑（Win 7系统）上可以访问samba和vsftpd以及ssh。

后来在终于在http://crazy123.blog.51cto.com/1029610/628287查到有人遇到同样的问题，解决方法为：打开本机（winxp）的设备管理器中找到本机的网卡，打开其属性窗口，在高级标签中找到“offload checksum”将其值置为“Disable”，按确认后，重启电脑就可以通过SSH访问了。

但是，我是Realtek的网卡，高级标签中没有“offload checksum”，更新网卡驱动到最新版本也没有这个选项，经过查找资料，“offload checksum”就是“硬件校验和”，将这项设为“关闭”，重启XP，问题解决了。好像只有Nvidia的网卡才有“offload checksum”这一项，Realtek网卡如下图所示：

昨天在微博上看到张孝祥老师突然病逝，我刚开始搞混了，我以为是孙鑫。孙鑫大家都知道，有一套视频教程讲VC++的，在BT上很火，但是后来不让下载了，说是孙鑫自己办了培训公司，因此不让这类视频在网上传播了。过了一段时间我才意识到我错了，张孝祥最初是讲Java，我Java入门就是看的他的视频，讲Java线程讲得特别清楚，他也创办了培训公司，但是所有的培训视频都在verycd上可以免费下载，全部公开的。顿时让我肃然起敬。

后来读张孝祥在CSDN上的博客，感觉到他的不容易。现如今，计算机科班毕业的大佬们看不起非科班的，就连称谓都有两种：程序猿和程序员。非科班的被认为只会编码，不懂架构，不懂算法的代码民工。而张孝祥做为“代码民工”的培训机构创始人，同样也被大多数人看不起，甚至是贬低，有些公司公然号称不招传智播客的毕业生，但是他还是坚持去做这一份事业。我想说的是，即使是计算机科班的毕业生在编程入门的时候谁不以能有通俗易懂的视频培训课程而感到幸福呢，更何况是所有的视频课程都能通过互联网进行下载，而且免费。这是不仅仅是一种自信，而是一种信仰，一种追求。这样的追求，谁也不能苛责。

中国的IT产业落后国外很多，虽然有多家号称巨牛逼的纳斯达克上市公司，但大多都依赖“墙”而生存。而国内的IT教育与国内外IT的发展就更加脱离甚远了。当今的中国IT事业之幸有张孝祥、孙卫琴这样的一流的入门技术书籍作者和培训师，太多的人因为他们而改变自己的生命，改变整个中国的IT产业。对他们，我们应该致敬。

最后，我想说的是，对于从农村、从家庭条件特别不好的家庭奋斗出来的男人，38岁正是事业像春天里生命旺盛生长的时候，但是张孝祥却突然与世长辞，令人扼腕，我翻看他的博客，翻到这样一篇题目的博文《累病倒了我两次的面试题–移动用户资费统计系统》，生命只有一次，请善待她吧。在Dian团队的同学们，身体是事业的本钱，坚持锻炼、坚持健康的生活习惯是事业的基础！

下面是他的一篇博客，不仅是他的故事，也是培训师的心声：《该不该从大学退学的讨论》，看完之后在Dian团队的同学们应该感恩，在大家的大学阶段遇到靠谱的学长带着自己入门，带着自己成长。

====================================

关于是直接在大学学本领，还是找一家可靠的培训机构学本领，不同性格、不同家境、不同学校、不同外部环境、不同机遇的人，他们的需求感和选择是不一样的，他们的成才方式也是不同的。另外，我发现那些自己本领不够但又不满意大学教育而迷茫辍学，或大学逃课出来培训的人几乎都是农村出来的，因为从小在缺钱的环境下长大，对拥有金钱的渴望程度更高，更渴望早点挣到钱，早一点摆脱经济上的拮据，早一点扬眉吐气，早一点补贴家庭，所以，他们更憧憬眼前的小成功、小利益，而无法静下心来去耐心追逐长远的宏伟目标，所以，很多农村出来的聪明孩子没有考研，而是大学毕业就迫不及待地出去工作和挣钱了。我就是这种情况的人，我从小就不是一个循规蹈矩和听话的孩子，我没有很强的决心和自制力，我经常自暴自弃，偶尔又能改良归正，我爱折腾，有梦想，但又没有毅力去坚持，我就是一个非常需要拜师学艺的人，但我要找到的一定是真有本领、又愿毫不保守教地教我的师傅。说说我的人生经历吧：

1. 从小生在农村、长在农村，并且属于环境特别不好的家庭。可以说完全是靠老天爷的眷顾而养大的，据说幼儿时候掉进集体公社的1两米深的大粪坑水池里，失去知觉幸亏被一路人发现而捞了上来，已经奄奄一息。

2. 记忆中是从小学三年开始赌钱，每次几分钱的输赢，但特上瘾和痴迷，上学和放学回家的路上都要赌上一会，课间更是不用说，为此挨了家长的不少棍棒，到小学五年级时（那时候五年制小学）居然已经会整天逃课赌钱了，自从那时候因此而被班主任语文老师重重打了一记耳光后，就切身感受了什么叫被打得两眼直冒金花了，这还不算完，第二天还要当着全校师生的面，在庄严的升旗仪式下作全校检讨。

3. 好在小学成绩一向都不错，稀里糊涂地以该小学第一名的成绩考上了当地的重点初中。上初中远离了家长的监管，更加肆无忌惮地赌钱了，地理、历史、体育、音乐等副课不计成绩，老师也不管，干脆直接外出赌钱。一起赌钱的小伙伴不敢逃语文、数学，英语等正课，没了赌友，只能陪着去上课，在课堂上还意犹未尽，钻到课桌底下继续赌，被老师发现拉出来又是几记重重的耳光。初一下学期期末考试成绩一塌糊涂，印象最深的是英语考了9分，这还是因为默写对了a到z之间的一些拼音字母才得到的分数，初一毫无悬念地留级了！我给大人们心目中留下的印象可能非常非常坏吧，我只知道初中是两个学生合伙睡一张床的，一个负责出床垫，另一个负责出被子，有个从小一起长大的小伙伴想和我合伙，可他们家长极力阻止，怕我带坏了小伙伴。

4. 初一复读，幸遇一恩师的关照，学习兴趣上来了，成绩不错，以全校第一名的成绩升入初二，还因成绩第一而被封为全校学习部长，初二上学期还算认真，下学期又开始逃课赌钱了，可见，我这个人很容易受到外界环境的影响，绝对是“近朱者赤， 近墨者黑”的典型，在顺利和良好的环境下，我可以发展得很好，在不利和不良的环境下，我会很颓废和放荡不羁。

5.初二初三一路玩过来，几乎完全忘记了学校是学习的地方，反而觉得学校是能远离家长监管的天堂，临近中考时，一起玩耍的同学都因读书无望而断断续续退学了，没有朋友一起玩了，一个人也玩不起来，只能拿起书本勉强自学吧，现在还记得中考时数学、物理、化学试卷的第一页做了些题，而第二页统统不会，交卷时第二页可谓一层不染。命运还挺照顾我，我居然糊里糊涂考上普通高中了，从所有老师们的言语中，我感受到了他们都很惊讶！但是不知什么原因，我的录取通知书是县里最差最差的八中，而比我成绩差的好些同学都上了好一点的三中。

6.家里走关系花钱让我上了三中，上高中班上60名同学，我成绩倒数几位，并且属于走关系进来的那一类特殊生。不知什么原因，就觉得自己要努力了，尽管许多与初二初三有衔接的数学物理课我都跟不上，甚至想找来初二初三的书本自己补习一下，期中考试居然进步神速，全班第四名，还被提成了小组长。可是，我这个人没有耐力、没有毅力，经不住不良环境的影响，又开始白天在教室睡觉，晚上整宿整宿地赌钱了，成绩又回到了班上倒数几名，班主任问过我一句：“明年你是不是不准备继续读书了？”

7.高二时突然想改变命运，开始废寝忘食地学习起来，居然取得了全年级第二名的好成绩，后来再也无法保持住第二名的成绩了，但成绩一直都还算上等，高中最大的收获就是几乎不听老师的课，全靠自学，自学能力倒是得到了锻炼和提高。因为我们那些老师自身的水平确实很差，问了老师们一些问题，他们总是解释不透彻，只是告诉你标准答案，而说不清为什么，最搞笑的是，每次英语女老师公布题目答案后，还问我答案为什么是这样的。现在回老家遇到一些高中老师，都是高中读书成绩不太好，通过复读勉强上了师范的一些昔日高中同学，他们本身就不太善于学习和总结，课讲不清楚是自然的，确实会耽误和影响一些学生的潜力。那些出类拔萃的学生大学毕业后都留在了大城市，而没有回到小县城去做高中老师。

8.如果相信命运的话，我肯定属于幸运的一类！高考比预期的结果好，居然成了三中的状元，也顺利进了北理工学机械。在北理工大一上学期很认真，很有抱负，因为对所学的功课不感兴趣，下学期又开始颓废了，一学期下来，最高时有两个月连续没进教学区，一日实在无聊想去教室看看，到了物理教室居然没见到一个同学，中午待同学们回宿舍后问原因，答曰早换教室一个多月了。一日数学老师在教室看见我，关心地问道“好久不见了，是不是回家了”。大三大四疯狂打了两年麻将，功课有四门补考，若再补考一门就没学位了，所以，因为学位的压力问题才勉强把大学的功课坚持学完，每次都是考试前一星期疯狂补课。

其实我不是一个自甘堕落和不可救药的人，我也是有理想和抱负的人，只是意志不坚强，遇到挫折就退缩就萎靡，在大学时我想成功，觉得学计算机编程来得最快，所以，自学了c语言，虽然计算机系的研究生说我的c语言水平比他们好些同学可能还高，但我总遇到问题后找不到人请教，也没有足够的上机环境，一个小问题压在心头三个星期得不到解决，最后又开始自暴自弃了，我也曾到中关村软件公司想找个师傅带我，但没有找到，所以又颓废了。我在想，对我这种自持力不强的人，如果有个好的师傅带，有个好的环境，让我先获得独挡一面的能力后，找到自己的兴趣点后，我就会非常努力和投入，就会取得较大的成绩，就能改变一辈子的命运。所以，我对软件培训班有特殊的理解和特殊的情意，那些一帆风顺的人是无法理解的。

最后，推荐是张孝祥最好的朋友郭新明的悼念文章：【追忆张孝祥】 郭新明：一辈子的朋友

我终于忍不住要写这篇博客，奉劝想省钱的朋友们：“便宜无好货”，而且不要被所谓的“华人”给骗了。

我是在找国外主机的时候发现WebHostingPad的，因为有介绍说创始人是华人，因此多了一份好感。价钱比较便宜，2-3美元一个月，而且还可以绑定无限个域名，其他的限制条件（如空间、文件数、流量）基本都是不限制，这对于我这个一直用国内主机的人来说是很兴奋的。大家都知道国内的空间总是限你的文件数目、数据库的个数等等等等，一遍又一遍的强奸用户。而且WebHostingPad还承诺一个月不满意就退款。

事实证明，一个月之内的确没有任何问题，网站速度也不错。当一个月满了，过了几天之后，帐号被禁用了。客服说CPU使用太多，我艹，我就一个WordPress，而且每天的独立IP也就70-100，这样也CPU使用太多？

我以为被挂马了，我把WordPress和数据下载下来，在本地分析之后，发现没有被挂马，一切正常，普通PC上访问一点问题都没有。我给客户说应该是你们的服务有问题，他说让我卸掉WordPress插件，于是我按照客服的要求，卸载了所有的WordPress插件，他们说CPU依然使用过多。

又按他们的要求将WordPress降到了旧的2.8版本，CPU还是使用过多。这让我很无语了。WebHostingPad用的是小霸王么、阿童木么？连个WordPress每天70-100的访问量都承受不了？

后来，我在找到下面一些文章：

1. WebHostingPad是不是骗子？
2. 谨慎：注册Webhostingpad免费域名
3. 美国主机WebHostingPad的最大文件数量限制
4. 美国主机WebHostingPad五个月评价

我突然醒悟了，难道是一个月退款期过了就想把我赶走么？找了客服，总是一遍又一遍说我的WordPress有问题，那为什么之前的一个月就一点问题都没有呢？我感觉，我应该被骗了。

下面是北山美国主机评论的原话，希望各位朋友警惕：

提示：经过几个月的使用和体验，WebHostingPad虽然便宜，但限制比较多，而且从商业的角度来说，存在信誉的问题，不建议购买WebHostingPad主机。

历史

1984年，MIT开始研究X Window System，用于在Unix上支持GUI界面，X Window System研究时是作为应用软件进行开发的，而不是操作系统。而且X Window System是作为架构规范进行研究，因此需要人和组织对其进行实现和包装（和linux一样，要有发行版）。

1987年，X版本更新到X11，这一版有非常明显的进步，因此后面X Window System也被称为X11，X11有通过网络功能访问GUI界面的功能，

1994年，X11R6发布，后来的架构都基于此版本，1995年发布X11R6.3。

前面提到X Window System是作为架构规范进行研究的，需要有人去实现，而1992年开始的XFree86项目就是这样一个被广泛使用的实现，名称来源于X+Free+X86架构。

2004年的时候，XFree86不在以GPL协议发布，而是另外成立了公司。X.Org基金会就从XFree86的派生出了另一个窗口系统，称为X.Org Server的X Window System。

现在X11最新的版本是X11R7.6，X.Org发布的X Window实现最新版本为1.11。

因此，我们称X、X Window、X11、xf86都是指代X Window System。

X的作用

X能为GUI环境提供基本的框架：在屏幕上描绘、体现图像与移动程序窗口，同时也受理、运行、及管理电脑与鼠标、键盘的交互程序。不过，X并没有管辖到用户界面的部份（可以理解为界面样式，如gnome和kde就外观完全不同），而是由其他以X为基础的界面实现来负责，也因为如此，以X为基础环境所开发成的视觉样式非常地多；不同的程序可能有完全不同的用户界面。

X的架构

X Window System由X Server（服务器）和X Client（客户端）两部分组成。X采行C/S的架构模型，由一个X服务器与多个X客户端程序进行通讯，服务器接受对于图形输出（窗口）的请求并反馈用户输入（键盘、鼠标、触摸屏），服务器可能是一个能显示到其他显示系统的应用程序，也可能是控制某个PC的视频输出的系统程序，也可能是个特殊硬件。前面提到的Xorg基金会发布的X.org Server就是一个服务端。

Linux系统在/etc/sysconfig目录中有键盘、鼠标等硬件的配置文件，但是因为X Server只是一个应用软件，因此他有自己的配置文件。X Server只有在run level 3的时候才会启动，因此只有在这个时候才会去用这些配置文件。

X的一大特点在于“网络透明性”：应用程序（“客户端”应用程序）所运行的机器，不一定是用户本地的机器（显示的“服务器”）。X中所提及的“客户端”和“服务器”等字眼用词也经常与人们一般想定的相反，“服务器”反而是在用户本地端的自有机器上运行，“客户端”是运行与远程服务器上的。客户端和服务器可以在同一台计算机上，也可以不是，或许其架构和操作系统也不同，但都能运行。

X Window Manager

这是一个特殊的X Client，负责管理所有的X Client。X Client之间是相互平等的，相互也不知道对方的存在。因此需要有个Window Manager对他们进行管理。主要负责：

1. 提供许多的配置选项，包括任务栏、背景桌面的设置等等；
2. 管理虚拟桌面 (virtual desktop)，Ubuntu里面称为工作区；
3. 提供窗口控制参数，如窗口的大小、重叠次序、窗口移动、窗口最小化等。

Gnome，KDE，XFCE就是所谓的X Window Manager

因此，在一台Linux机器上，我们必须要安装Xorg的X Server，才能接收到键盘等交互设备的输入、才能在窗口上绘制图形界面。为了更好的管理图形界面，于是还需要安装Gnome这样的X Window Manager。

Display Manager

如果已经登录了，在文字界面下输入startx就可以启动X图形系统。但是一般的图形界面linux系统会在系统启动后让你进行登录，这个登录界面就是Display Manager了，主要提供登录的功能，并且载入用户选择的X Window Manager的配置（我们可以在ubuntu启动的时候选择使用Gnome3还是Gnome Classical，或者可能还有Xfce，如果你安装了XFCE的话）。

gdm就是Gnome Display Manager了。

启动X Window System的流程

文字界面下使用startx启动X图形系统，startx实际上是一个Shell脚本，其作用是使用当前用户默认的X Server的配置启动X Window System。startx实际上是通过执行xinit来启动X图形系统的。

X Server的启动参数才/etc/X11/xinit/xserverrc中，X Client的参数在/etc/X11/xinit/xinitrc。具体的参数另行撰文。

参考

1. 维基百科：X.org
2. 维基百科：X Window

题注：本书的标题全名为《设计与生存————一位IT设计管理人员20年的经历与感悟》

很久以前就看到团队藏书里面有一本书叫《设计与生存》，2006年出版，时隔今日已5年，在半年就技术升级的IT世界，已经算是老龄了，所以给我最初的映像是装帧土气、历史久远，“历史久远”绝对不是褒义。不过副标题“一位IT设计管理人员20年的经历与感悟”却是引起了我的注意，人生能有几个二十年呢？于是我拿起这本其貌不扬的书快速地浏览了一下，顿时就被吸引了。看完第一章就对作者马宁伟先生的奋进、执着和思考由衷的敬佩。我立马想到新浪微博上找这个作者，可惜看到的是马先生因为肝癌已经离我们远去，我根据网上的资料推测应该是2011年初。在此以表达对马宁伟先生的缅怀。马先生的简介http://baike.baidu.com/view/1885686.htm。

作者77年进入宿迁无线电厂工作，因为文革期间很多大学教授到被下放到这里，于是作者有幸跟随大师学习和工作。不过正如作者自己说的“师傅领进门，修行在个人”，作者依靠自己“勤奋”和“爱动脑筋”，成为骨干。1985年在国企非常有前瞻性的开始做一些研究上的东西，虽然技术资料很少，获得极为不便，但是仍然坚持读英文原版书。我想到团队藏书里面整整二三十本原版书居然没有任何一个人读，感觉万分惭愧。之前听华域王建平总裁讲座，说“你们生逢盛世”，当时毫无感触。阅读了马宁伟先生的文字，顿时感同身受。

这本书告诉我们的不仅是为人处世、管理团队的经验，更是在讲述那个时代的精神——我们这个时代已经丢掉的勤奋、专研、踏实、负责的精神。

作者的语言非常的朴素，甚至非常口语化，和作者自称只有“电大”的学历到是很相称，但是语言朴素却掩盖不了道理的深邃，掩盖不了思想的光芒。下面是摘抄的一些句子，大部分是我感同身受的道理。

1. 写技术论文不仅使自己进一步理清思路，也会加深对问题的理解，因为你写的时候才会发现，有些问题原理自己也和不清楚，给别人讲课也是如此。写和讲两件事都是看起来实在帮别人，实际上也是与己有益的事。后来，我对工程师的要求都是要会做，会写和会讲。
2. 成功的转折来自于对社会、行业、自身的了解和积极的准备，来自于忧患意识，这样才能抓住时机。
3. （计算机）……原本大家都清楚这只是一种工具，是次要因素，但实际上却成了正真的一道逾越不过去的墙，结果真正重要的工程师的思维分析能力、实际经验反而无用武之地。
4. 电视是一个给人带来娱乐的好东西，但是看长了也是使人弱智的东西，因为从人的接收能力来讲，图像比文字来的容易得多，电视看多了，脑筋就动的少，脑力自然不发达。而读文字的时候需要你思考，才能理解；需要从文字中将图形在脑中成像，这就锻炼了脑力。
5. 一个好的设计师，一定要用心做事，技术上的事是躲不过去的，今天没有仔细去合算上下两种工作极限的状况，明天一定会让你十倍的头痛。“天道酬勤”讲的就是这个道理。
6. 我们那时能凝聚一批工程师，在人员流动率比较高的深圳保持了人员稳定，并且快速出了成果和人才，今天回头看，主要靠的是三条：第一是公司有一定的知名度；第二是大家有事做，有技术学；第三是部门风气正，奖罚分明。
7. 在很多管理细节上，并不要花钱，就是需要有人以“服务”的心态去做。而传统的行政人事部门，工作的出发点就是“管”，其实真要管的东西不多，多向前走一步，帮人忙的事情倒是很多，以服务的心态去做事，别人的感觉就会舒服了，做事效率自然就高了。
8. （得人心者能成事）……我的管理原则一直是用能人，绝不会因个人的喜好去埋没人才，一个员工在他进门的时候会看他的文凭和工作背景，进公司后只会看他的实际能力。
9. 不是每个技术好的工程师都能做好管理。
10. 展示产品形象的要素：
    1. 市场定位的用户群体
    2. 提炼三条左右的卖点
    3. 在同类产品中的功能优势
    4. 产品技术方面所达到的高度（国内先进水平，还是什么水平）
    5. 目前研发进展
    6. 何时可以量产
11. 由于长年的阅读习惯，我读书的速度是很快的，一夜可以读完厚厚的一本。基本上我采用的是第一遍快速地读，记下大致内容，等到用时就知道这个问题在那本书上谈到过，在拿出来细看。
12. （建立企业文化的方法之一）……使用漫画家郑辛遥的哲理漫画做辅助，“生活就是这样充满遗憾，当你擦玻璃的时候，脏的东西总是在另一面”，“生气的后果永远比生气的原因严重，擦伤引起的争吵几乎总是以刺伤搞结束”
13. （企业文化）……不愿意做技术传承的工程师，不能在这个中心工作，这就是我们的一个“天条”。
14. （企业文化）……团队合作来源于体育界的球队，要点是个人各就各位，分工合作，而不是几个人做同样的事。
15. （组织架构、职责划分）……我的体会是职责划分越清楚，越利于项目组成员的执行，做事效率也越高。不会出现一件事多人重复做，或者一件事没有人做的情况。有一些公司不愿意在职责划分上花些时间将其定义清楚，而是一味地要员工“主动”，那不是一个好的做法，有时也会造成低效率。“主动”仅应该体现在两人职责的交接处，没发写清楚的细节部分。“做我该做，说我该说”才是一个有序的团队。
16. 师傅领进门，修行在个人——大事是靠培养出来的吗？大画家、大作家、设计大师都是初期得到引导，后期自身修炼的结果。
17. 有测试表明：创造性思维的能力强的人，智商只是中等水平。
18. 一个团队的知识互补是重要的。
19. 对于工程师来说，一个共同的需求就是英文的要求。凡是想做好技术的工程师，英文是必需的，因为大部分深层的技术资料都是英文的。
20. 情商（EQ）是只一个人对情绪的自我认知、自我控制、自我驱策能力以及对他人反馈能力和情绪的识别这5个方面的能力。
21. （应届毕业生的选择）……“大水出大鱼”，刚毕业的学生要尽可能进大公司。即使你打定注意要自己创业，这也是一条很好的起步之路。知名外企和一流的台资大公司都有相当完善的用人制度、各种管理方法和各种作业流程，做事的观念和方法与学校中收到的教育和主流媒体宣传的也大不相同，对人的评价体系就大不相同。进入这些企业是极好的改变自己的机会，也是给自己一个崭新的视角去看问题。
22. 最重要的就是选择适合你自己的个性、职业发展的公司，选择于你最为重视的价值观相一致的企业，选择植根你内心的人生兴趣相一致的专业。
23. 技术人员书读多了，整天用的是逻辑思维，自然是敏感而多疑，执着甚而固执；想得到别人承认，却又表现得满不在乎；希望碰到知己者，又常感怀才不遇。
24. 有人说，这个世界上人类已经没有共同的理想。其实不然，受过高等教育的研发工程师心中始终埋藏着公平、民主、自由的社会理想，一旦有机会就会表现出来。
25. 我比较推崇的管理方法是职责明晰、流程清楚、方法规范、公平竞争。从管理风格上我喜欢直面事实，不绕弯说出自己的观点，尤其是对技术问题。但这种管理风格对心理脆弱的人效果不好……，所以我会避开这类人。
26. 管理靠细致，对作业面的所有工程师，“心细如发”可能是共同的个性特质要求。……（粗心的表现）……分析下来，也许并不是不负责任，而是心粗。为此，我曾对两位屡教不改的粗心工厂是做过一种培训，就是每天话一小时，让他们吧一碗黑白混合的芝麻分开。……我们还举行用筷子同时夹起三粒生花生米的训练。
27. 建立checklist机制。
28. 在高速运行的企业，最好的报告是“让上司走出电梯前就能看完的报告”。怎样可以做到这样的效果？这就需要反其道而行之，先写结论，在写论证过程，附相关数据表格。
29. 软件行业有一句著名的格言“进来的是垃圾，出去的还是垃圾”。意思是不把工作要求了解清楚，就想当然的做下去，结果一定是产出一堆无用的东西。
30. 新产品研发失败的主要原因有：人不行、钱不够、管理不善、市场不对路。
31. 有没有分析能力是判断一个低阶技术人员和中介技术人员的分水岭。分析能力的强和弱是中高级人才的判断标准之一。
32. 公司前任总经理Steven对流失员工的态度是，他走来走去，还是在这个行业。他到我们的上游企业，我们可能多了一个客户；他到我们的下游企业，以后他会帮我们订货便宜一点；到了我们同行那里，我们多了一个了解信息的渠道；他就是离开这个行业，我们还是可以做朋友。
33. 思维不清晰，不简洁，说话空泛，不能一语中的，这些是中国内地工程师普遍存在的问题，这些缺陷严重地影响了做事的效率。

如果有读者坚持读到这里了，我在透露一点最有用的道理——一定要亲自去看一下这本书，不然只看我的摘要是没有感觉的，呵呵。

简述

最开始的时候，Linux上的软件以源代码的方式发布，用户下载源代码包（通常打包为.tar.gz），然后自行编译。

dpkg是Debian软件包管理器的基础，它被伊恩·默多克创建于1993年。dpkg与RPM十分相似，同样被用于安装、卸载和供给和.deb软件包相关的信息。

dpkg本身是一个底层的工具，本身并不能从远程包仓库下载包以及处理包的依赖的关系，基于dpkg的上层工具，如APT，则用于从远程获取软件包以及处理复杂的软件包关系。

APT全称Advanced Packaging Tool，可以自动下载，配置，安装二进制或者源代码格式的软件包，因此简化了Unix系统上管理软件的过程。现在Debian和其衍生发行版（如Ubuntu）中都包含了APT。

APT最早是基于dpkg的开发的，只用来处理deb格式的软件包。现在经过APT-RPM组织修改，APT已经可以安装在支持RPM的系统管理RPM包。

而aptitude是一个APT的文本界面客户端，现在也逐渐加入了GUI的界面，详见http://linuxtoy.org/archives/gtk-gui-for-aptitude.html

Synaptic是Ubuntu中自带的APT的GUI客户端，也就是传说中的新立得。

dpkg命令

(来自：http://linuxtoy.org/archives/dpkg_reference.html)

注意：更多选项可通过 dpkg -h 查询，有些指令需要超级用户权限才能执行

APT命令

(来自：http://linuxtoy.org/archives/apt_reference.html)

备注：package 为软件包名称。

aptitude命令

（来自http://linuxtoy.org/archives/aptitude_quick_reference.html）
aptitude是基于APT的又一个包管理的前端，aptitude似乎在处理依赖问题上更佳一些。据说aptitude 另外用一份数据量很小的扩展标记来实现所谓更佳的管理，我没有发现有什么比apt命令更加牛逼的功能，不过看起来命令比apt要简洁。

当然aptitude也是text-based，也就是命令行模式的

Synaptic

由于synaptic是GUI界面的，没啥命令好说的，其实这个在Ubuntu里面也挺少用到的，更多的还是通过apt-get命令就可以搞定。

因为之前写过《使用PyXMPP向GTalk发送消息》一文，最近被一个研究XMPP协议的学妹问到XMPP协议中的资源（Resource）的意思。其实我开始也是一知半解，而且学妹挺诚心的样子，就仔细看了看XMPP协议的文档，这里也感谢这位学妹提供的XMPP协议（RFC3920）的中文版和英文版，其实我以前写用pyxmpp的时候也没有仔细看XMPP协议的。

不看不知道，一看吓一跳，原来所谓的Resource和我一直很欣赏的Google Talk的多客户端同时在线的功能有关系，Google Talk就是基于XMPP协议的。

首先举几个JID的例子，比如下面几个都是完整的JID:

xxx@gmail.com /gtalk-client
xxx@gmail.com /plus.google.com
xxx@gmail.com /gmail
xxx@gmail.com /sony-errision-x10-android

JID实际上是3部分组成的：节点名（上面四个JID中的“xxx”），域名（上面四个JID中的“gmail.com”，一般是主服务器的域名），资源名（上面四个JID中最后面不同的那部分）

这四个JID都对应到某人的google帐号（xxx@gmail.com），只不过一个对应windows gtalk客户端，第二个对应google plus网页的上的那个聊天窗口，第三个对应google talk的网页窗口，第四个对应手机上的google talk。注意这里资源的名字只是我自己瞎想出来的，可能一般实现的时候会直接有服务器生成一个随机字符串吧。

和QQ不一样的是，XMPP允许一个帐号在不同的地方登录，比如我的电脑、google plus网页、gmail、手机上的google talk现在都是登录状态，别人给我发送消息的时候，我的四个client都会提示我有收到新的消息，但是当我选择用手机回复的时候，本次会话（session）所有消息都会只发送到我的手机，而其他的client（如windows上的google client、gmail里面的client）就不会再收到消息了。

因此除了帐号(xxx@gmail.com)以外，会有另外一个标识符来标识我使用的这种client，这个client就是上文提到的resource，这里上面4个帐号中，email地址后面的字符串就是resource id了

因此为了确认你使用的哪一个客户端，需要resource绑定。绑定后的JID才是一个完整的JID。

上面就是我对XMPP中Resource的理解，也特别感谢这位学妹的问题，才让我对XMPP有了更深入了解的机会。

今晚意外的聆听了新东方俞敏洪老师的演讲《相信未来》，结束的时候，俞老师背诵了这首《相信未来》。听到这首倍感熟悉的诗，我突然记起高中的时候我曾经疯狂的迷恋这首诗，甚至比《山高路远》（没有比人更高的山/没有比脚更长的路）一样。

突然记起，我已经好久，没相信未来。

我曾经很乐观，认为我可以搞定一切，但是随着年龄的增长，逐渐认识到自己的力量永远是一颗小水珠，只能在初夏早晨的那一刹那，彩虹洋溢。慢慢的开始认命。

中考那年，妈找了个瞎眼算命先生给我算命，当时深受受马克思辩证唯物主义毒害，于是当着算命先生的面发了句牢骚，说“算命都是见鬼的”，方言“见鬼”表示深深的轻蔑和不屑。算命先生没责怪我的意思，不过我也没拗过妈，抽了个签。算出来的具体是什么命我记不得，我妈估计记得，只隐约记得是长大了要做大官。我则再次表达了不屑。

算命先生走后，妈教育我，即使不信命，也不能说那样的话，至少要对算命先生表示尊重。这么多年以来，每当在天桥上、地下通道口看到乞讨的老人，我总想起这句话。

十年后，在校外办完事情匆忙走在大城市武汉的街头，不经意瞥到路边摆摊算命的算命先生，眼睛不瞎的那种。突然心头一动，有种冲动想算一下命，虽然在心中仍然觉得算命实在是件荒唐的事儿。可是，就是有那么一股子冲动，现在依然有。

又过了几年的一个五一节，妈来武汉玩儿几天。妈那个时代的农村妇女对黄鹤楼都有一种莫名的情节，他们经常对我说的是“湖北有个黄鹤楼,半截伸在天里头”。反而在武汉生活了8年多的我没有任何感觉，带妈爬上了黄鹤楼，她很高兴，拍了不少照片。我心想，有点想头真好。

当然不得不去归元寺，我外婆是虔诚的佛教徒，我外公患上肝癌的时候开始信的，直到现在外公都已经去世十四年，她还供奉着观音娘娘。大名鼎鼎的归元寺自然也得带我妈去看看。到了罗汉堂，有求签，解签。我好像也虔诚了，听从了妈，花了二十块钱解签，具体什么内容现在恐怕也得问她了。我印象最深的是，高僧解签是要花更多的钱的，这无疑让我对佛曰“众生平等”的印象大打折扣，看起来佛也喜欢的是有钱人。

直到今天，突然有听到这首诗，突然醒悟，命运原来不在算命先生嘴巴里，也不在佛祖的签上，却是在你我的意识里，深深的潜藏。该信未来。

前文Eclipse JFace Binding/绑定 (1)”和Eclipse JFace Binding/绑定 (2)”分别讲述了JavaBean API的事件机制和Eclipse JFace Binding的SWT控件属性和JavaBean属性的绑定。本文是本系列的最后一篇，讲述JFace中TableViewer、TreeViewer和ListViewer的绑定，由于TableViewer比较有代表性，因此使用TableViewer作为示例。

为什么需要WritableList、WritableSet和WritableMap

在做任何事情之前，先要提出一个为什么，“当你保持一颗好奇的心，当你愿意去问“为什么”，而不是一味得不假思索得接受，你便能够从一件事物的不同角度去审度，你就站得更高，看得更远”——这是 《Sandra Lee: 人生很短，做自己喜欢的事 》中的一句话，我很喜欢。

提出这个问题，潜台词肯定是为什么不能直接用List、Set、Map呢？原因在于集合对象不同于普通对象，集合对象包括了一组对象，这组对象本身的属性改变需要监听自然不必说，对象的添加、删除也是需要监听的，因此Java Collection API中的List、Set和Map就不够用了，更何况几何对象中所包括的那一组对象还必须封装到一个WritableValue对象中，不然元素和GUI的绑定又得失效了。

那么这么多复杂的工作就让WritableList去干吧。

JavaBean中的List属性

我们先模拟一下有钱人，他们都能买几套房子，因此都有几个地址，将地址列表作为有钱人的一个属性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

package com.zhlwish.jfacebinding.model;
 
import java.beans.PropertyChangeSupport;
import java.util.ArrayList;
import java.util.List;
 
public class RichPerson extends PropertyChangeSupport {
 
	public RichPerson() {
		this(null);
	}
 
	public RichPerson(Object sourceBean) {
		super(sourceBean);
	}
 
	private String name;
	private List<address> addresses;
 
	public String getName() {
		return name;
	}
 
	public void setName(String name) {
		this.firePropertyChange("name", this.name, this.name = name);
	}
 
	public List</address><address> getAddresses() {
		if(addresses == null){
			addresses = new ArrayList</address><address>();
		}
		return addresses;
	}
 
	public void setAddresses(List</address><address> addresses) {
		this.firePropertyChange("addresses", this.addresses,
				this.addresses = addresses);
	}
 
	public static class Address extends PropertyChangeSupport {
 
		public Address() {
			this(null);
		}
 
		public Address(Object sourceBean) {
			super(sourceBean);
		}
 
		private String street;
		private String city;
 
		public String getStreet() {
			return street;
		}
 
		public void setStreet(String street) {
			this.firePropertyChange("street", this.street, this.street = street);
		}
 
		public String getCity() {
			return city;
		}
 
		public void setCity(String city) {
			this.firePropertyChange("city", this.city, this.city = city);
		}
	}
}
</address>

将List绑定到TableView上

下面的目标是将List绑定到TableView上，首先我们不管RichPerson这个master，先对付一个Address的列表绑定。下面代码先创建了一个addresses列表。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

ArrayList addresses = new ArrayList<address>();
Address address = new Address();
//暴露了，暴露了
address.setCity("武汉");
address.setStreet("珞喻路");
addresses.add(new Address());
 
DataBindingContext bindingContext = new DataBindingContext();
 
//设置ContentProvider
ObservableListContentProvider listContentProvider = new ObservableListContentProvider();
tableViewer.setContentProvider(listContentProvider);
 
//设置LabelProvider
IObservableMap[] observeMaps = BeansObservables.observeMaps(
				listContentProvider.getKnownElements(), 
				Address.class, new String[]{"city", "street"});
tableViewer.setLabelProvider(new ObservableMapLabelProvider(observeMaps));
 
//设置Input
WritableList writableList = new WritableList(addresses, Person.class);
tableViewer.setInput(writableList);
</address>

好啦，这样就完了，我们在TableView中去添加，删除会直接绑定到addresses列表上。其实看起来和TableView显示普通List也没有什么区别，老三样：设置ContentProvider、设置LabelProvider、
设置Input，只不过这里升级了，不再是ArrayContentProvider，也不是LabelProvider而是ObservableListContentProvider和ObservableMapLabelProvider了。

将RichPerson对象中的addresses属性绑定到TableView

严格意义上来讲不是将RichPerson对象的属性绑定到底TableView，而是将RichPerson对象的代理WritableValue的addresses属性绑定到TableView。因为如果只是RichPerson对象，那么就和前面的没有什么区别了，创建WritableList的时候直接像下面这样写就完了：

1

WritableList writableList = new WritableList(richPerson.getAddresses(), RichPerson.class);

为了尝试一点不同，我们先创建一个封装了richPerson的WritableValue对象，如下：

1
2
3

RichPerson richPerson = new RichPerson();
WritableValue model = new WritableValue();
model.setValue(richPerson);

好吧，终于快结束了，这里隆重推出在Eclipse JFace Binding/绑定 (2)”中已经提到，但是没有说明的observeDetailList()方法，此方法有三个参数:

1. 第一个是master对象，这里就是我们在上面代码中创建的model
2. 第二个是属性名称，这里我们要绑定RichPerson对象的addresses属性
3. 第三个是属性的元素类型，这里我们要绑定的是Address类型

因此，绑定的代码如下，前面的设置ContentProvider和设置LabelProvider是一样的，最后的两句话修改如下。这里需要注意的是writableList变成了IObservableList类型，因为WritableList继承自IObservableList，而且observeDetailList返回值也是IObservableList，我没有尝试去做强制类型转化，当然，你可以试一下。

1
2
3

//设置Input
IObservableList writableList = BeansObservables.observeDetailList(model, "addresses", Address.class);
tableViewer.setInput(writableList);

小结
写了一天，终于写完了，之所以一定要写下来，因为Eclipse JFace的Binding机制的确给我这样的懒程序猿带来了很大的好处，而且在Eclipse的代码里面学到了很多设计模式的作用，如策略模式、观察哲模式、装饰器模式、简单工厂模式。另外，由于我能找到的材料都是英文的，中文基本没有，有也是翻译的英文，而且以示例为主，没有总结和分析，因此就下决心要写下来。等我有空了，在翻译成英文的样子，发布出去。

前文《Eclipse JFace Binding/绑定 (1)》介绍了JavaBean的事件机制，Eclipse的绑定利用了这种机制，（据说Eclipse Binding的下一个目标是Pojo对象的双向绑定，利用asm这样的字节码操作库）。

绑定针对对象实例而不是类型

在深入之前，需要明确的是，在Java中绑定永远是针对对象实例的绑定，而不是针对对象类型的绑定。也就是说下面的代码会使model之前注册的监听器失效。

Model model = new Model();
model.addPropertyChangeListener(new IPropertyChangeListener(){
	public void propertyChangeListener(PropertyChangeEvent evt){
		System.out.println(evt.getPropertyName() + “ changed”);
	}
});
model = new Model();

IObservable接口

Eclipse绑定的核心是IObservableValue、IObservableList，通过实现这些接口对GUI和模型进行监听，我把实现了这些接口的对象成为绑定对象。包括：

1. IObservable – 所有Observable接口的根接口，提供了对对象实例变化的监听机制
2. IObservableValue – 提供了getValue()和setValue()方法，提供了监听value改变的机制
3. IVetoableValue – 继承自IObservableValue，提供了在value变化之前进行事件处理的机制
4. IObservableCollection – 继承自java.util.Collection和IObservable
5. IObservableList – 继承自java.util.List和IObservableCollection，提供了监听list中元素添加、删除、修改事件的机制
6. IObservableSet – 继承自java.util.Set和IObservableCollection，提供了监听set中元素添加、删除、修改事件的机制
7. IObservableMap – 继承自java.util.Map和IObservable，提供了监听map中元素添加、删除、修改事件的机制

其类图如下：

值得注意的是上面类图中有一个ISWTObservable，封装了SWT控件，提供了监听SWT控件变动事件的机制。

IObservable工场方法

为简化绑定对象的创建，JFace Binding框架提供了三个工厂方法类：SWTObservables，BeansObservables和PojoObservables。

BeansObservables

定义于org.eclipse.core.databinding.beans包，创建实现了PropertyChangeListener的JavaBean的可观察对象, 其方法有两个系列：

1. observeXXX(其中XXX为Value, Map, List, Set)
2. observeDetailXXX(其中XXX为Value, Map, List, Set)

Person person = new Person();
IObservableValue usernameObservableValue = BeansObservables
						.observeValue(person, "username");

上面方法创建了一个监控person对象的username属性改变的IObservable对象。

PojoObservables
定义于org.eclipse.core.databinding.beans包，创建基于Pojo的可观察对象，即模型对象无需实现PropertyChangeListener接口，这对于JavaBean是无侵入性的，在我们的项目中，JavaBean有JAXB从XML Schema生成，最初也是Pojo，看起来用这样的绑定方式是很好的。但是目前的版本并没有实现Pojo对象到SWT控件的绑定，即不能实现双向绑定，因此基本等于没有。

因此我们不得不手动的编码让每个类实现PropertyChangeListener。

SWTObservables
定义于org.eclipse.jface.databinding.swt包，创建基于SWT控件的可观察对象，如创建基于txtUserName文本输入控件的值改变的观察者：

ISWTObservableValue txtUserNameObservableValue = SWTObservables.observeText(txtUsername);

上面代码创建的创建了一个监控txtUserName文本输入控件的输入值变化的IObservable对象。

绑定SWT控件和Model属性

将两个IObservable对象进行绑定是通过DataBindingContext类来实现的，这个类中定义了签名为bindValue(target, model, targetToModelUpdateValueStrategy, modelToTargetUpdateValueStrategy)的方法。此方法返回一个Binding对象。看起来挺复杂。

1. 第一个参数是绑定目标对象，经常是ISWTObservableValue对象；
2. 第二个参数是绑定模型对象，经常是IObservableValue对象；
3. 第三个参数是绑定对象属性值转化和校验策略，可以设置将目标对象属性值转化模型对象属性值时所有的转化器（如StringToIntegerConvertor、IntegerToStringConvertor）和对目标对象属性值的校验器（如StringToDateValidator），一般情况下是null
4. 第四个参数和第三个参数刚好相反，是模型对象属性值到绑定目标对象属性值的转化和校验策略，一般情况下是null

下面代码将我们之前创建的txtUserNameObservableValue和usernameObservableValue绑定起来，由于两者都是String类型，无需转化器：

DataBindingContext bindingContext = new DataBindingContext();
bindingContext.bindValue(txtUserNameObservableValue, usernameObservableValue, null, null);

校验并显示错误

如果业务需要强制要求GUI上username文本输入框必须输入不少于5个字符的字符串，那么我们就需要定义校验器：

public class UsernameValidator implements IValidator {
	@Override
	public IStatus validate(Object value) {
		if(value instanceof String){
			if(value.toString().length() < 5){
				return ValidationStatus.error("用户名长度不少于5个字符");
			}else{
				return ValidationStatus.ok();
			}
		}
		return ValidationStatus.error("用户名只能是字符串");
	}
}

然后我们创建一个UpdateValueStrategy，将以上定义的校验器加入到策略对象中：

UpdateValueStrategy strategy = new UpdateValueStrategy();
strategy.setBeforeSetValidator(new UsernameValidator());
Binding bindValue = bindingContext.bindValue(txtUserNameObservableValue, 
						usernameObservableValue, strategy, null);

当然，加入校验器还有一个原因是要能在界面上实时地显示校验错误，在上面代码最后一行加入下面一行代码之后就会显示错误提示，如下图所示：

ControlDecorationSupport.create(bindValue, SWT.TOP | SWT.LEFT);

解决“绑定针对对象实例而不是类型”提到的问题

在前面提到，绑定针对对象实例而不是类型，即将对象model绑定到GUI界面上后，如果model对象的属性变化了，GUI界面会立刻得到通知，但是当对象本身被替换成了别的对象，绑定就会失效了。在我们的项目中有这样一个需求，先解析XML文件生成模型对象，然后将该模型对象绑定到GUI界面中，当XML文件被其他修改后，GUI界面要立即同步更新。但是问题是XML文件修改后，应用程序立即重新解析XML文件，生成的是一个新的模型对象，于是出现了之前提到的对象被替换，绑定失效的问题。这类问题在Eclipse JFace Binding被成为Master-Detail的绑定问题。

为了解决这类型的问题，Eclipse JFace Binding提供了WritableValue、WritableList、WritableMap和WritableSet四个类。

WritableValue

WritableValue是代理模式的一种实现，其内部拥有一个引用指向实际的模型对象，这样，你可以将这个代理绑定到GUI界面，例如下面的代码，就可以保证对象model到GUI界面的绑定仍然有效：

Person person = new Person();
private WritableValue model = new WritableValue();
model.setValue(person);
model.addPropertyChangeListener(this);
person = new Person();
model.setValue(person);

对于person的属性username和txtUsername文本输入框之间的绑定现在需要做如下修改：

IObservableValue usernameObservableValue = BeansObservables
			.observeDetailsValue(model, "username", String.class);

第一个参数是所谓的master对象，第二个参数是属性名称，第三个是属性的类型（直接写null也行）

小结
到目前为止，Eclipse JFace Binding的核心部分基本讲解完毕，对于简单对象的绑定应该是没有问题，不过除了简单控件之外，Eclipse中还会大量使用TableView、ListView、TreeView这样的viewer，他们就不是简单的绑定一个JavaBean属性，而是需要绑定一个List/Tree或者一个Map，又复杂起来了，下文再讲。

参考
http://java.sun.com/developer/onlineTraining/Beans/JBeansAPI/shortcourse.html
http://wiki.eclipse.org/index.php/JFace_Data_Binding
http://www.vogella.de/articles/EclipseDataBinding/article.html

binding这个词挺有意思的，中文意译为“绑定”，音译也可以是”绑定“，但是“绑定”这个词看起来又不是像“巴士”这样的词一样属于外来词。我深深地感觉第一个把binding翻译成“绑定”的人当时一定感觉很好。

为什么需要“绑定”

在MVC架构中，View（GUI）上的控件的值来源于Model，用户在View上的操作也需要更新到Model。由于桌面应用程序的实时响应特性，后台服务（如数字校验、根据单价和数量计算总价）对Model的更新也需要实时通过View反馈给用户。

Java应用中，Model和View都是相互独立的JavaBean。JavaBean API中，Bean之间的通信通过事件传递实现。事件在一方属性变化时被创建，然后传递给响应变化的一方，后者从事件对象中获取事件信息，进而调用相应的方法实现响应操作。

一般情况下，GUI操作以及Model的属性变化被封装成一个事件对象（Event），事件对象一般包括了事件发生的来源（控件或者模型），变化之前的值和变化之后的值。如对于JavaBean API中定义的类PropertyChangeEvent，有source、propertyName、oldValue、newValue四个属性。

模拟Model和View的“绑定”

GUI和Model的绑定使用观察者模式来实现，也就是常说的Observable模式，不过在JavaBean的事件模型里面叫做Listener模式。不同的叫法实质是一样的，Observable是针对被观察的对象而言，Listener则是针对观察其他对象的对象而言。

Observable模式在Java API中有支持，可以直接继承java.util.Observable来实现一个被观察类，通过实现java.util.Observer接口实现观察者，然后调用Observable.addObserver(Observer)方法来建立消息发送渠道。这种方法存在的问题就是，被观察者类必须继承Observable类，由于Java是单继承，因此这个类就不能继承其他类了。

JavaBean API中提供IPropertyChangeListener接口和PropertyChangeSupport类来实现Bean之间的事件通信。我们创建如下两个类：

1. Window：模拟GUI中的窗口，包括txtUsername和txtPassword两个文本输入框
2. Model：模式实体类，包括username和password两个字符串属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

package com.zhlwish.binding;
 
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
 
public class Window{
	private PropertyChangeSupport pcs = new PropertyChangeSupport(this);
 
	private String txtUsername;
	private String txtPassword;
 
	public String getTxtUsername() {
		return txtUsername;
	}
	public void setTxtUsername(String txtUsername) {
		pcs.firePropertyChange("txtUsername", this.txtUsername, 
				this.txtUsername = txtUsername);
	}
	public String getTxtPassword() {
		return txtPassword;
	}
	public void setTxtPassword(String txtPassword) {
		pcs.firePropertyChange("txtPassword", this.txtPassword, 
				this.txtPassword = txtPassword);
	}
 
	public void addPropertyChangeListener(PropertyChangeListener listener){
		pcs.addPropertyChangeListener(listener);
	}
 
	public void removePropertyChangeListener(PropertyChangeListener listener){
		pcs.removePropertyChangeListener(listener);
	}
}

Window类中，当调用set方法设置值的时候，同时调用firePropertyChange()方法通知监听器（listener）。而且提供addPropertyChangeListener()和removePropertyChangeListener()两个方法添加和删除监听器。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

package com.zhlwish.binding;
 
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
 
public class Model implements PropertyChangeListener{
	private String username;
	private String password;
 
	public String getUsername() {
		return username;
	}
 
	public void setUsername(String username) {
		this.username = username;
		System.out.println("username update to : " + username);
	}
 
	public String getPassword() {
		return password;
	}
 
	public void setPassword(String password) {
		this.password = password;
		System.out.println("password update to : " + password);
	}
 
	@Override
	public void propertyChange(PropertyChangeEvent evt) {
		System.out.println("Model has recived the change");
		if(evt.getPropertyName().equals("txtUsername")){
			this.setUsername((String) evt.getNewValue());
		}else if(evt.getPropertyName().equals("txtPassword")){
			this.setPassword((String) evt.getNewValue());
		}
	}
}

Model类实现了PropertyChangeListener接口，因此必须实现PropertyChangeListener中定义的propertyChange()方法。在此方法中，根据PropertyChangeEvent对象中携带的不同信息进行处理。

1
2
3
4
5
6
7
8
9
10

package com.zhlwish.binding;
 
public class Main {
	public static void main(String[] args) {
		Window w = new Window();
		Model m = new Model();
		w.addPropertyChangeListener(m);
		w.setTxtPassword("new password");
	}
}

Main充当了控制器的作用，创建Window和Model，然后设置Model监听Window的改动，之后模拟用户通过GUI修改txtPassword，程序的结果输出如下：

Model has recived the change
password update to : new password

模拟双向绑定

上面仅仅实现了单项的绑定，即View的改变会告知Model，但是Model的改变不会被告知View。为实现双向绑定，需要向GUI和Model相互注册为对方的Listener，以响应对方的改动。

因此，此时不仅Model需要实现PropertyChangeListener，Window也需要实现该接口，需要实现响应对方改动的处理方法，具体代码比较长，当然这也是在具体应用的时候不可能直接使用此API的原因–实现代码太长了。长长的代码请下载http://zhlwish.googlecode.com/files/eclipse-binding-1.tar.gz

小结

由于事件处理函数集中于propertyChange()方法，需要根据不同的属性变化调用不同的方法处理，会导致该方法冗长繁琐，这是一个问题。另外，在从Model到View，从View到Model会涉及一些数据类型转换，和数据校验，这部分是需要像你我这样的程序猿去自己实现的，对于我这样的懒人来讲也是一个问题。第三，在每个set方法里面去编写firePropertyChange()这样的方法我也觉得很繁琐，而且容易出错，这也是一个问题。

最后，最重要的，这只是一个模拟，还没有涉及到AWT/Swing或者SWT/JFace中的控件的事件处理，什么onChange(),onSelection()……，必然的还会实现很多ActionListener这样的匿名内部类，oh，gosh！

不过，看起来Eclipse的开发人员也意识到了这个问题，在JFace中已经加入了Binding这样的组件，我们可以直接使用这样一些组件方便的快捷的实现Model到View的绑定。

ps.有什么方法可以很好的表现观察着模式么，UML类图只是静态关系，看不来任何实质的，因为涉及对象与对象的交互，可能序列图会更好，不过我没有尝试去画过。

很长一段时间没有继续写了，很多东西都快忘记了，赶紧捡起来

让你的GEF图元可以拖动和缩放

拖动算是最简单的用户交互吧，不过麻雀虽小，肝胆俱全，不理解其原理和设计思路，很难谈得上去应用，但是要理解这一整套交互模型又有相当的难度，本文虽重在实践，这里也略做介绍。后文中所述图元指EditPart对象实例。

GEF用户交互有四个重要的概念：Command，Policy，Request，Role

1. GEF图元对于用户操作的响应（具体的执行操作）被称为Command，这是命令模式的典型实现

   

2. GEF图元对于用户操作采用何种响应（操作->响应）被称为EditPolicy，这是策略模式的典型实现，Policy可以认为是一个Map，输入一个Request，输出其对应的Command

   

3. 用户对图元的操作（拖拽、选择）被称为Request

   

4. 用户对图元的操作是可以分类的，这个类型被称为Role。比如拖动图元移动位置，拖动图元边框改变图元大小是影响布局的操作，称为LAYOUT_ROLE；双击图元修改图元上的文字信息，双击连线上的问题修改连线的说明，这些都是直接对图元进行修改的操作，称为DIRECT_EDIT_ROLE……，这样的操作类型有很多，以后有机会再进行系统的总结。

对于用户的操作，图元使用那种响应策略（是边框变粗、还是Label变成Input接受用户输入），取决于图元上注册的事件响应类型（Role），当然我们可以向图元同时注册多个响应策略，用于响应不同的用户输入：

installEditPolicy(EditPolicy.LAYOUT_ROLE, new DiagramLayoutEditPolicy());

关于此installEditPolicy()方法，我同组的小牛分析得比较透彻，看他：http://www.thankcreate.com/java/357

OK, 下面我们开始编码。

创建Command

首先创建一个Command类，用于响应用户的拖拽操作，com.zhlwish.learngef.command.AjustNodeConstraintCommand继承自org.eclipse.gef.commands.Command，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public class AjustNodeConstraintCommand extends Command {
 
	private GraphicalEditPart editPart;
	private Rectangle newBounds, oldBounds;
 
	public AjustNodeConstraintCommand(EditPart child, Object constraint) {
		editPart = (GraphicalEditPart) child;
		newBounds = (Rectangle) constraint;
		oldBounds = new Rectangle(editPart.getFigure().getBounds());
	}
 
	@Override
	public void execute() {
		redo();
	}
 
	@Override
	public void redo() {
		GraphicalEditPart parent = (GraphicalEditPart) editPart.getParent();
		parent.setLayoutConstraint(editPart, editPart.getFigure(), newBounds);
	}
 
	@Override
	public void undo() {
		GraphicalEditPart parent = (GraphicalEditPart) editPart.getParent();
		parent.setLayoutConstraint(editPart, editPart.getFigure(), oldBounds);
	}
 
}

这段代码很容易理解，将之前的constraint保存起来，将新的contraint应用到图元上，GEF的图形API以后有机会再详述。

创建Policy

由于我们现在处理的是布局，因此创建com.zhlwish.learngef.policy.DiagramLayoutEditPolicy，使其继承org.eclipse.gef.editpolicies.XYLayoutEditPolicy，由于XYLayoutEditPolicy已经实现了底层的一些细节（getCommand()方法实现了根据Request类型查找对应的Command），我们只需要重写createChangeConstraintCommand()即可，此方法默认返回null，因而图元不会执行拖拽和缩放请求的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class DiagramLayoutEditPolicy extends XYLayoutEditPolicy {
 
	@Override
	protected Command getCreateCommand(CreateRequest request) {
		return null;
	}
 
	@Override
	protected Command createChangeConstraintCommand(
			ChangeBoundsRequest request, EditPart child, Object constraint) {
		if(child instanceof NodePart){
			if(constraint instanceof Rectangle){
				return new AjustNodeConstraintCommand(child, constraint);
			}
		}
		return super.createChangeConstraintCommand(request, child, constraint);
	}
}

安装Policy

“安装”这个字眼有点让人不安，这里这么说主要是因为实现此功能的方法叫installEditPolicy()，暂且就这么叫吧。

如果我没记错的话，com.zhlwish.learngef.part.DiagramPart类中应该有个空的方法叫createEditPolicies()，在里面添加一个个语句，看见没installEditPolicy()第一个参数就是我们所说的请求的类型（Role）：

1
2
3

protected void createEditPolicies() {
	installEditPolicy(EditPolicy.LAYOUT_ROLE, new DiagramLayoutEditPolicy());
}

运行

到目前为止，所需要的编码工作就已经完成了，运行程序，此时你会发现已经可以对图元进行移动了，鼠标移动到边框上还可以缩放图元，和下面的图一样。

一直比较喜欢ibus，毕竟是官方支持，而且的确比较简单，不用像其他的输入法，配置繁杂不说，还经常出问题。添加了中文语言支持时会自动安装ibus，然后添加拼音输入法就可以用了。

最近新安装了Ubuntu11.04，发现找不到设置双拼的地方了，经过探索发现，首先在ibus首选项中修改“Show language panel”为“always”。

然后在任意能输入的地方，Control+space切换输入法，这时出来一个工具条：

点击齿轮图标（Preference）,打开ibus-pinyin选项，切换到Pinyin mode选项卡，然后选择”Double pinyin”即可，默认双拼方案为MSPY，我猜是微软双拼，ZRM就是我用的自然码方案啦。

将View中的图形移到编辑器中

在View中是不能对图形进行移动、修改大小的，需要对图形进行修改必须使用Editor，因此，我们首先创建一个GEF编辑器，然后将图形显示在编辑器中。

创建编辑器

打开plugin.xml，打开Extensions标签页，添加org.eclipse.ui.editors扩展，然后添加一个Editor，Name为Nodes GEF Editor，Extensions为gef，如下图所示:

创建NodeGefEditor类，继承自GraphicalEditorWithFlyoutPalette，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

package com.zhlwish.learngef.editor;
 
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.gef.DefaultEditDomain;
import org.eclipse.gef.palette.PaletteRoot;
import org.eclipse.gef.ui.parts.GraphicalEditorWithFlyoutPalette;
 
public class NodeGefEditor extends GraphicalEditorWithFlyoutPalette {
 
	public NodeGefEditor() {
	}
 
	@Override
	protected PaletteRoot getPaletteRoot() {
		return null;
	}
 
	@Override
	public void doSave(IProgressMonitor monitor) {
	}
 
}

设置EditDomain

首先在构造函数中设置EditDomain，如下：

1
2
3

public NodeGefEditor() {
	setEditDomain(new DefaultEditDomain(this));
}

显示图形

接着覆盖间接父类GraphicalEditor的configureGraphicalViewer()方法，设置EditPartFactory和RootEditPart，可以和一步一步实现GEF – 4中的NodeGefView类的代码进行比较，代码如下：

1
2
3
4
5
6
7
8
9
10
11

@Override
protected void configureGraphicalViewer() {
	super.configureGraphicalViewer();
 
	GraphicalViewer viewer = getGraphicalViewer();
	viewer.setEditPartFactory(new PartFactory());
 
	ScalableFreeformRootEditPart rootEditPart = 
		new ScalableFreeformRootEditPart();
	viewer.setRootEditPart(rootEditPart);
}

为了能尽快的在编辑器中显示图形，我们直接通过GraphicalViewer的setContents()方法显示通过硬编码创建的一个Diagram，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

@Override
protected void initializeGraphicalViewer() {
	super.initializeGraphicalViewer();
 
	GraphicalViewer viewer = getGraphicalViewer();
 
	Diagram diagram = new Diagram();
 
	Node node = new Node();
	node.setText("测试节点");
	node.setLocation(new Point(10, 10));
	diagram.addNode(node);
 
	Node node2 = new Node();
	node2.setText("测试节点");
	node2.setLocation(new Point(100, 170));
	diagram.addNode(node2);
 
	Connection conn = new Connection();
	conn.connect(node, node2);
 
	viewer.setContents(diagram);
}

这段代码和一步一步实现GEF – 6是不是又完全一样呢？

运行

好啦，到了这里可以运行项目了，运行后，创建一个名称任意（我的叫testgef）的项目，然后在项目中创建一个test.gef（名称随意，后缀名只能是gef）的文件，然后双击打开这个文件，应该看到下面的这个图：

工具条
编辑器的右边，有个三角形，鼠标移动上去，就会有个工具条展开，如下图所示：

当然，还可以通过以下方法来设置工具条的样子，如显示在编辑器的左边而不是右边，或者让工具条在编辑器打开的时候就显示等。不过这个并不重要，因此，此处仅仅提示，并不深入说明，有兴趣可以自己看代码。

1
2
3

getPalettePreferences().setDockLocation();
getPalettePreferences().setPaletteState();
getPalettePreferences().setPaletteWidth();

无法拖拽

如果你比较好奇，肯定会尝试去用鼠标拖动图形，但是很遗憾，拖不动。怎么样才能使用鼠标拖动图形，移动图形到任何位置呢，敬请期待下文。

添加Tooltips

我们希望用户将鼠标移动到图元上时，能够友好的显示图元的一些详细信息，可以通过Tooltip的方法实现。GEF中Figure类中定义了图元的Tooltip，其类型为IFigure，因此我们可以创建一个Label，然后将Label作为图元的Tooltip显示。
在NodeFigure类中添加一个私有方法createToolTip()，将结点的位置和背景的颜色显示给用户。

1
2
3
4
5
6
7

private Figure createToolTip(){
	Label tooltip = new Label();
	String color = model.getColor().toString();
	String loc = model.getLocation().toString();
	tooltip.setText(color + ", " + loc);
	return tooltip;
}

之后在NodeFigure的构造函数中调用setToolTip()给图元设置Tooltip（下面代码的倒数第二行）

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public NodeFigure(Node node) {
	model = node;
 
	label = new Label();
	label.setText(model.getText());
	label.setForegroundColor(Activator.getDefault().getColor(new RGB(0, 0, 0)));
	add(label);
 
	//通过模型获得位置
	Point loc = model.getLocation();
	setBounds(new Rectangle(loc.x, loc.y, 200, 50));
	setBackgroundColor(Activator.getDefault().getColor(model.getColor()));
	setToolTip(createToolTip());
}

运行程序，这时将鼠标移动到结点上时，就可以显示出Tooltip了，如下图：

一口气发了6篇关于Eclipse GEF开发的文章，主要是记录这几天来的学习和整理所得，但是目前还没有整理完，只是涉及到在视图中显示GEF图形，到编辑器中的GEF图形编辑这个目标才完成了1/5，只怪GEF太复杂，马上会放假回家，休息一个星期再继续。

添加连接线

要在两个结点（Node）之间显示连接线，需要在模型上添加连接线，修改showDiagram()函数，在node和node2之间添加一个Connection对象，为了方便，先在Connection类中添加connection()方法，如下所示：

public void connect(Node source, Node target){
	setSource(source);
	setTarget(target);
	source.addOutgoingConnection(this);
	target.addIncomingConnection(this);
}

接着在showDiagram()方法中创建Connection模型对象，并且连接node和node2。

private void showDiagram() {
	Diagram diagram = new Diagram();
 
	Node node = new Node();
	node.setText("测试节点");
	node.setLocation(new Point(10, 10));
	diagram.addNode(node);
 
	Node node2 = new Node();
	node2.setText("测试节点");
	node2.setLocation(new Point(10, 70));
	diagram.addNode(node2);
 
	Connection conn = new Connection();
	conn.connect(node, node2);
 
	graphicalViewer.setContents(diagram);
}

运行程序，但是很遗憾，连接线依然没有显示。

显示连接线

考虑到在《一步一步实现GEF – 5》一文中也出现过创建了模型，但是模型不显示的问题，解决办法是覆盖DiagramPart父类的getModelChildren()方法。以此类推，我们应该覆盖NodePart父类的getModelSourceConnections()和getModelTargetConnections()方法，返回Node模型的Outgoing Connections和Incoming Connections。

为了方便起见，我们为Node模型添加如下两个方法，分别返回Outgoing Connections和Incoming Connections。

1
2
3
4
5
6
7

public List<Connection> getIncomingConnections() {
	return incomings;
}
 
public List<Connection> getOutgoingConnections() {
	return outgoings;
}

接着在NodePart类中添加如下方法：

1
2
3
4
5
6
7
8
9

@Override
protected List<Connection> getModelSourceConnections() {
	return ((Node) getModel()).getOutgoingConnections();
}
 
@Override
protected List<Connection> getModelTargetConnections() {
	return ((Node) getModel()).getIncomingConnections();
}

然后运行程序，我们可以看到，两个结点之间出现了一根细实线，也就是我们需要的连接线了。

自定义连接线

但是仍然有遗憾，就是连接线似乎并没有显示出箭头，或者，我们想连接线应该显示为虚线，这样又该如何实现呢？有两个方法，一是为Connection模型创建专门的Figure，二是通过覆写ConnectionPart类的父类AbstractConnectionEditPart的createFigure()方法。方便起见，我们选择第二种。

AbstractConnectionEditPart的createFigure()方法中创建了PolylineConnection连接线，我们直接对这个连接线进行修改。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

@Override
protected IFigure createFigure() {
	PolylineConnection conn = (PolylineConnection) super.createFigure();
 
	//连接线宽度为4
	conn.setLineWidth(4);
 
	//设置连接线为虚线，实线长度为4，空白长度为1
	conn.setLineDash(new float[]{4f,1f});
 
	PolylineDecoration decoration = new PolylineDecoration();
	decoration.setLineWidth(4);
 
	conn.setTargetDecoration(decoration);
	return conn;
}

为了更好的显示出连接线的状态，我们修改NodeGefView的showDiagram()方法，将第二个结点的位置向右下移动：

1

node2.setLocation(new Point(100, 170));

然后运行程序，这时候的效果图应该如下：

显示Diagram模型

到目前为止，仅仅显示了一个节点（Node）的图形，如何显示多个节点，也就是一个Diagram的模型呢？

我们修改NodeGefView类的showDiagram()方法，创建Diagram模型，并且创建两个Node模型，加入到Diagram中。

private void showDiagram() {
	Diagram diagram = new Diagram();
 
	Node node = new Node();
	node.setText("测试节点");
	node.setLocation(new Point(10, 10));
	diagram.addNode(node);
 
	Node node2 = new Node();
	node2.setText("测试节点");
	node2.setLocation(new Point(10, 70));
	diagram.addNode(node2);
 
	graphicalViewer.setContents(diagram);
}

但是运行时发现，现在视图上无显示，连上一步显示的Node模型对应的矩形框都没有了。

解决这个问题，我们通过覆盖DiagramPart的父类的getModelChildren()方法实现，此方法默认返回空列表。首先在Diagram模型类中加入一个返回其孩子结点的方法：

public List<Node> getNodes() {
	return nodes;
}

接着，覆盖DiagramPart的父类的getModelChildren()方法，返回Diagram模型的孩子结点。

@Override
protected List getModelChildren() {
	Diagram diagram = (Diagram)getModel();
	return diagram.getNodes();
}

此时运行插件，看到的效果应该如下图所示：

创建View

打开META-INF/MANIFEST.MF，在Extensions页面添加org.eclipse.ui.views扩展点，并添加一个名为“Nodes GEF View”的扩展点。

创建View对应的Java类

自定义视图需要继承自ViewPart类型，通过覆盖createPartControl()方法自定义视图上显示的内容。此处视图上显示一个ScrollingGraphicalViewer，GraphicViewer需要设置rootEditPart和EditPartFactory，然后调用setContent()方法传入模型对象，该方法能根据模型的类型生成相应的EditPart，然后创建相应的Figure并加入显示队列中进行绘图。

1
2
3
4

ScalableFreeformRootEditPart rootEditPart = new ScalableFreeformRootEditPart();
ScrollingGraphicalViewer graphicalViewer = new ScrollingGraphicalViewer();
graphicalViewer.setRootEditPart(rootEditPart);
graphicalViewer.setEditPartFactory(new PartFactory());

整个View类的代码如下，我们自己定义了一个私有showDiagram()方法创建模型并调用setContent()方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

package com.zhlwish.learngef.view;
 
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.gef.editparts.ScalableFreeformRootEditPart;
import org.eclipse.gef.ui.parts.ScrollingGraphicalViewer;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.part.ViewPart;
 
import com.zhlwish.learngef.Activator;
import com.zhlwish.learngef.model.Node;
import com.zhlwish.learngef.part.PartFactory;
 
public class NodeGefView extends ViewPart {
 
	private static Color COLOR_WHITE = Activator.getDefault().getColor(
			new RGB(255, 255, 255));
 
	private ScrollingGraphicalViewer graphicalViewer;
 
	public NodeGefView() {
		super();
	}
 
	@Override
	public void createPartControl(Composite parent) {
		ScalableFreeformRootEditPart rootEditPart = 
				new ScalableFreeformRootEditPart();
		graphicalViewer = new ScrollingGraphicalViewer();
		graphicalViewer.createControl(parent);
		graphicalViewer.getControl().setBackground(COLOR_WHITE);
		graphicalViewer.setRootEditPart(rootEditPart);
		graphicalViewer.setEditPartFactory(new PartFactory());
 
		showDiagram();
	}
 
	@Override
	public void setFocus() {
		graphicalViewer.getControl().setFocus();
	}
 
	private void showDiagram() {
		Node node = new Node();
		node.setText("测试节点");
		node.setLocation(new Point(10, 10));
 
		graphicalViewer.setContents(node);
	}
}

运行此插件，点击菜单Window->Show View->Others，找到Other节点，展开后点击“Nodes GEF View”视图，打开后，可以看到节点显示在了视图上。

实现模型对应的Part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

package com.zhlwish.learngef.part;
 
import org.eclipse.draw2d.IFigure;
import org.eclipse.gef.editparts.AbstractGraphicalEditPart;
 
import com.zhlwish.learngef.figure.NodeFigure;
import com.zhlwish.learngef.model.Node;
 
public class NodePart extends AbstractGraphicalEditPart{
 
	@Override
	protected IFigure createFigure() {
		return new NodeFigure((Node) getModel());
	}
 
	@Override
	protected void createEditPolicies() {
	}
 
}

1
2
3
4
5
6
7
8
9
10
11
12

package com.zhlwish.learngef.part;
 
import org.eclipse.gef.editparts.AbstractConnectionEditPart;
 
public class ConnectionPart extends AbstractConnectionEditPart{
 
	@Override
	protected void createEditPolicies() {
 
	}
 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

package com.zhlwish.learngef.part;
 
import org.eclipse.draw2d.IFigure;
import org.eclipse.gef.editparts.AbstractGraphicalEditPart;
 
import com.zhlwish.learngef.figure.DiagramFigure;
 
public class DiagramPart extends AbstractGraphicalEditPart {
 
	@Override
	protected IFigure createFigure() {
		return new DiagramFigure();
	}
 
	@Override
	protected void createEditPolicies() {
 
	}
 
}

实现根据模型的类型创建相应的EditPart的工厂

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

package com.zhlwish.learngef.part;
 
import org.eclipse.gef.EditPart;
import org.eclipse.gef.EditPartFactory;
 
import com.zhlwish.learngef.model.Connection;
import com.zhlwish.learngef.model.Diagram;
import com.zhlwish.learngef.model.Node;
 
public class PartFactory implements EditPartFactory{
 
	@Override
	public EditPart createEditPart(EditPart context, Object model) {
		EditPart part = null;
		if(model instanceof Node)
			part = new NodePart();
		if(model instanceof Connection)
			part = new ConnectionPart();
		if(model instanceof Diagram)
			part = new DiagramPart();
		if(part != null)
			part.setModel(model);
		return part;
	}
 
}

创建模型对应的Figure

由于节点对应的Figure中需要使用Color，因此先在Activator类中加入ColorRegistry类型的属性，修改之后如下，其中第20行和第50行以后为新增加的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

package com.zhlwish.learngef;
 
import org.eclipse.jface.resource.ColorRegistry;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.ui.plugin.AbstractUIPlugin;
import org.osgi.framework.BundleContext;
 
/**
 * The activator class controls the plug-in life cycle
 */
public class Activator extends AbstractUIPlugin {
 
	// The plug-in ID
	public static final String PLUGIN_ID = "com.zhlwish.learngef"; //$NON-NLS-1$
 
	// The shared instance
	private static Activator plugin;
 
	private ColorRegistry colorRegistry = new ColorRegistry();
 
	/**
	 * The constructor
	 */
	public Activator() {
	}
 
	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext)
	 */
	public void start(BundleContext context) throws Exception {
		super.start(context);
		plugin = this;
	}
 
	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext)
	 */
	public void stop(BundleContext context) throws Exception {
		plugin = null;
		super.stop(context);
	}
 
	/**
	 * Returns the shared instance
	 *
	 * @return the shared instance
	 */
	public static Activator getDefault() {
		return plugin;
	}
 
	public Color getColor(RGB rgb){
		Color color = colorRegistry.get(rgb.toString());
		if(color == null){
			colorRegistry.put(rgb.toString(), rgb);
		}
		color = colorRegistry.get(rgb.toString());
		return color;
	}
 
}

GEF严格遵循MVC架构实现，Figure是模型对应的图形，由于Diagram对应整个GEF图形，因此继承FreeformLayer

1
2
3
4
5
6
7
8
9
10
11
12

package com.zhlwish.learngef.figure;
 
import org.eclipse.draw2d.FreeformLayer;
import org.eclipse.draw2d.FreeformLayout;
 
public class DiagramFigure extends FreeformLayer{
 
	public DiagramFigure() {
		this.setLayoutManager(new FreeformLayout());
	}
 
}

Node类代表一个节点，我们用矩形框内嵌入文本显示，因此NodeFigure继承自RectangleFigure，同时使用setBounds()方法将Label的大小和位置设为和矩形框一致，这样文本就会在中间显示。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

package com.zhlwish.learngef.figure;
 
import org.eclipse.draw2d.Label;
import org.eclipse.draw2d.RectangleFigure;
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.swt.graphics.RGB;
 
import com.zhlwish.learngef.Activator;
import com.zhlwish.learngef.model.Node;
 
public class NodeFigure extends RectangleFigure {
 
	private Node model;
	private Label label;
 
	public NodeFigure(Node node) {
		model = node;
 
		label = new Label();
		label.setText(model.getText());
		label.setForegroundColor(Activator.getDefault().getColor(new RGB(0, 0, 0)));
		add(label);
 
		//通过模型获得位置
		Point loc = model.getLocation();
		setBounds(new Rectangle(loc.x, loc.y, 200, 50));
		setBackgroundColor(Activator.getDefault().getColor(model.getColor()));
	}
 
	public void setBounds(Rectangle rect){
		super.setBounds(rect);
		this.label.setBounds(rect);
	}
}

由于Connection代表的是连接线对象，为简单的折线，此处不专门为其指定专门的Figure。

创建项目

创建Eclipse Plugin项目，名称为com.zhlwish.learngef

打开META-INF/ MANIFEST.MF，在Dependencies标签页上Required Plug-ins区域，添加名称为org.eclipse.gef的插件依赖。

创建模型

定义三个模型类，Diagram，Node，Connection，分别代表整个GEF图，节点，节点之间的连线，GEF图类由结点组成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

package com.zhlwish.learngef.model;
 
import java.util.ArrayList;
import java.util.List;
 
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.swt.graphics.RGB;
 
public class Node {
 
	private String text = "";
	private RGB color = new RGB(120, 120, 120);
	private Point location = new Point(0, 0);
 
	private List<Connection> incomings = new ArrayList<Connection>(0);
	private List<Connection> outgoings = new ArrayList<Connection>(0);
 
	public String getText() {
		return text;
	}
 
	public void setText(String text) {
		this.text = text;
	}
 
	public RGB getColor() {
		return color;
	}
 
	public void setColor(RGB color) {
		this.color = color;
	}
 
	public Point getLocation() {
		return location;
	}
 
	public void setLocation(Point location) {
		this.location = location;
	}
 
	public void addIncomingConnection(Connection conn){
		incomings.add(conn);
	}
 
	public void rmIncomingConnection(Connection conn){
		incomings.remove(conn);
	}
 
	public void addOutgoingConnection(Connection conn){
		outgoings.add(conn);
	}
 
	public void rmOutgoingConnection(Connection conn){
		outgoings.remove(conn);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

package com.zhlwish.learngef.model;
 
public class Connection {
 
	private Node source;
	private Node target;
 
	public Node getSource() {
		return source;
	}
 
	public void setSource(Node source) {
		this.source = source;
	}
 
	public Node getTarget() {
		return target;
	}
 
	public void setTarget(Node target) {
		this.target = target;
	}
 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

package com.zhlwish.learngef.model;
 
import java.util.ArrayList;
import java.util.List;
 
public class Diagram {
 
	private List nodes = new ArrayList(0);
 
	public void addNode(Node node){
		nodes.add(node);
	}
 
	public void rmNode(Node node){
		nodes.remove(node);
	}
}

一个类在没有显式定义构造函数的时候，Java会隐式提供一个无参数的构造函数。但是当显式定义了构造函数的情况下，Java就不会提供这个无参数的构造函数了。这是由于在显式定义的构造函数中可能进行了一些必要的初始化工作，此时如果错误调用默认无参构造函数会导致这些必须的初始化工作并没有完成，进而导致程序异常。

经过编程实践，本人认为还是有必要再显式定义了有参构造函数的情况下，仍然显式定义一个无参构造函数。主要原因是“最好提供缺省值”（It will be better to provide a default value），另外一个原因则是在工厂方法中大量使用的java.lang.Class.newInstance()方法只能调用无参构造函数。

提供缺省值
在定义类的时候，最好为属性设置缺省值，以免出现Java中最常见的NullPointException，如下所示，当然此代码并不涉及构造函数神马事情，此处省略不相关的部分，下文类似。

1
2
3

public class NodeEditPart{
	private List<Connection> incomings = new ArrayList<Connection>(0);
}

通过构造函数设置属性值是非常常见的。下面代码摘取自java.awt.Label类，其中定义了空的构造函数，并且设置文本默认为空字符串。

1
2
3
4
5
6
7
8
9
10

public Label() {
	this("", LEFT);
}
public Label(String text) {
	this(text, LEFT);
}
public Label(String text, int alignment) {
	this.text = text;
	setAlignment(alignment);
}

用newInstance()方法创建对象
下面代码定义了ElementFactory工厂类，通过构造函数传入类型对象(java.lang.Class)，然后调用newInstance()创建对象。由于newInstance()只能调用无参构造函数，因此如果类不定义无参构造函数，则无法使用此方法进行创建，这也是此方法不安全的原因所在。当然如果必要的话，也可以使用反射的方式调用有参构造函数，只是相应比较复杂。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class ElementFactory {
 
	private Object template;
 
	public ElementFactory(Object template) {
		this.template = template;
	}
 
	public Object getNewObject() {
		try {
			return ((Class) template).newInstance();
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}
 
	public Object getObjectType() {
		return template;
	}
}

客户端使用此方法的时候如下，如果Label不定义无参构造函数，则会抛出异常：

1
2

ElementFactory factory = new ElementFactory(Label.class);
Label label = (Label) factory.getNewObject();

总结
以上只是本人在开发过程中的一点心得，也是避免发生运行时异常的一种好的编程习惯，如果不对，敬请指正。

参考

Using Java Reflection
Java关键字new和newInstance的区别方法

版权
本文是本博客原创文章，您可以自由转载，但转载请注明来源。

< 全文完>

白娘子的配音太像了：
http://v.youku.com/v_show/id_XMjg5ODMwMjQ4.html

为什么老美喜欢有事儿没事儿都拿点酒出来喝呢，不管是在办公室还是在家里，而且好像吃饭的时候都不喝酒，这种风俗来自于哪儿？截图来自于《State.of.Play》

Google Music绝对是虾米这样的网站的克星，本地上传+云存储+在线播放+Android云同步，如果只是提供给用户存储的空间而不传播，应该不会有版权问题吧。我有4个邀请码。http://music.google.com/

我准备把《建党伟业》下到电脑上看一下，看看历史是如何被捏造，被美化。或者我本不应该以历史的角度去看待这部献礼的“电影”。

ok，又不是专门的技术讲座，没有必要讲这么清楚的吧，而且别人公司的关注点并不在于图像的识别技术嘛。

非常漂亮简洁的主题，不像suffusion那么复杂，至少对我来讲suffusion太复杂了，链接地址：http://wpthemes.info/misty-look/

早就听说wordpress开始支持aside了，没尝试过，现在试一下效果

研究SWT Layout原理的时候，找到一个视频：《Creating a Custom Window Layout in Eclipse RCP Applications》，顿时被作者使用的GridLayoutFactory和GridDataFactory惊艳了，前些天，我还傻乎乎的自己写了几个简单的类实现相同的功能，无知真可怕。本文介绍了此两个类的用法，最后有一个简单的示例。

GridLayout

SWT有四种布局方式：FillLayout，RowLayout，GridLayout，FormLayout，其中使用后三种布局方式的时候，需要为每个子控件指定专门的layout data，分别是RowData，GridData和FormData，这些布局方式和相关的设置，有篇德文的文章《SWT Layout-Manager》讲解得异常清楚，不懂德文不要紧，就看里面的图就行了，在此我转载两张关于GridLayout的图：

GridLayout的属性

GridData的属性

使用GridLayoutFactory

先说GridLayoutFactory，一般我们要创建一个GridLayout需要这样：

GridLayout layout = new GridLayout(2, false);
layout.marginHeight = 10;
layout.marginWidth = 10;
layout.horizontalSpacing = 5;
layout.verticalSpacing = 5;

而GridLayoutFactory则可以这样创建：

GridLayoutFactory.fillDefaults().numColumns(2).margins(10, 10).spacing(5, 5).create();

GridLayoutFactory的方法介绍如下：
创建型

属性设置型

其他

一般创建一个GridLayout然后应用到控件Composite上的方法如下：

Composite btnBar = new Composite(parent, SWT.NONE);
GridLayout layout = new GridLayout(2, false);
layout.marginHeight = 10;
layout.marginWidth = 10;
layout.horizontalSpacing = 5;
layout.verticalSpacing = 5;
btnBar.setLayout(layout );

使用GridLayoutFactory则可以简单的写成：

Composite btnBar = new Composite(parent, SWT.NONE);
GridLayout layout = GridLayoutFactory.fillDefaults().numColumns(2)
                                     .margins(10, 10).spacing(5, 5).create();

btnBar.setLayout(layout);

或者更简单的：

Composite btnBar = new Composite(parent, SWT.NONE);
GridLayoutFactory.fillDefaults().numColumns(2)
                                .margins(10, 10).spacing(5, 5).applyTo(btnBar);

使用GridDataFactory

既然同是Factory，就总有几分相似，GridDataFactory的public方法如下：

以往在给一个控件设置GridData的代码如下：

GridData gd = null;
gd = new GridData(GridData.FILL_HORIZONTAL);
gd.grabExcessHorizontalSpace = true;
txtLoginPwd.setLayoutData(gd);

使用GridDataFactory则可以简单的写成：

GridDataFactory.fillDefaults().grab(true, true).applyTo(txtLoginPwd);

结语

本文介绍了如何使用GridLayoutFactory和GridDataFactory方便编写SWT UI程序的时候使用GridLayout布局。其实，在相同的包下还有RowLayoutFactory和RowData，其使用方式和前面介绍的大同小异，只需要查看Java Doc即可以容易理解。另外，相同的包下还引入了TableColumnLayout和TreeColumnLayout两个高级的布局方式，此布局方式目前尚不清楚。

摘要：在进行Eclipse RCP开发的过程中，需要使用一些其他的资源（如图片、声音、配置文件、数据库等），我们一般将这些资源放到Plugin/Bundle的相应目录下（如图片资源放到icons目录，声音放到sounds目录，数据库文件放到data目录）。本文先对Eclipse Plugin和Bundle进行分析，之后讲解了如何使用Eclipse API通过这些资源的相对路径（相对于Plugin/Bundle）获取这些资源的绝对路径的方法，最后总结了org.osgi.framework.Bundle接口和FileLocator工具类的使用方法。

Bundle和Plugin

Eclipse Platform架构于OSGi核心之上，每个Eclipse Plugin就是OSGi的一个Bundle，因此在Eclipse RCP中Plugin和Bundle是等价的概念。

OSGi框架中定义了org.osgi.framework.IBundle接口，表示运行于OSGi环境中的一个Bundle。Eclipse RCP中定义了org.eclipse.core.runtime.Plugin抽象类，代表一个Eclipse插件。但是Plugin抽象类并没有实现IBundle接口，而是在内部拥有一个IBundle对象实例。Plugin类实现了BundleActivator，控制其内部的IBundle对象的启动和停止，并负责将BundleContext注入到IBundle对象实例中。

我们可以发现，在IBundle接口中定义了如下几个方法，可以获取位于在Bundle文件目录中的资源：

如何获取当前的Bundle对象

开发Eclipse Plugin/Bundle应用首先需要创建Activator类，继承自org.eclipse.ui.plugin.AbstractUIPlugin，该类继承自上文提到的org.eclipse.core.runtime.Plugin类，OSGi框架在加载Plugin/Bundle的时候首先加载此Activator类，然后调用此类中定义的start(BundleContext context)和stop(BundleContext context)方法启动和停止这个Plugin/Bundle。在这个类的父类Plugin中声明了Bundle类型实例，可以通过getBundle()方法获取这个Bundle实例。

以下代码为Activator类中的start(BundleContext)方法，在其中调用了getResource(String)和getEntry(String)两个方法，同时调用FileLocator.toFileURL(String)将URL转化为文件系统的路径

public void start(BundleContext context) throws Exception {
	super.start(context);
	plugin = this;
	System.out.println(Activator.getDefault().getBundle().getLocation());
	URL url = Activator.getDefault().getBundle().getResource("META-INF/MANIFEST.MF");
	System.out.println(url);
	System.out.println(FileLocator.toFileURL(url));
 
	URL url2 = Activator.getDefault().getBundle().getEntry("META-INF/MANIFEST.MF");
	System.out.println(url2);
	System.out.println(FileLocator.toFileURL(url2));
}

上面代码输出结果为：

reference:file:/D:/demo/modeling-workspace/com.zhlwish.proppagedemo/
bundleresource://709.fwk15218962:1/META-INF/MANIFEST.MF
file:/D:/demo/modeling-workspace/com.zhlwish.proppagedemo/META-INF/MANIFEST.MF
bundleentry://709.fwk15218962/META-INF/MANIFEST.MF
file:/D:/demo/modeling-workspace/com.zhlwish.proppagedemo/META-INF/MANIFEST.MF

通过结果可以很明显看到，使用getResource(String)和getEntry(String)获取到的URL是OSGi环境中的路径，需要通过FileLocator.toFileURL(String)方法将OSGi环境中的URL转化为文件系统中的URL。

至于getResource()和getEntry()有什么区别，我到Eclipse Forum里面提了问题，回答是：

1. getResource uses the bundle’s class loader to load a resource. This resource could come from imported constraints (Import-Package, Require-Bundle) or from the local bundle classpath.
2. getEntry only searches the bundles jar files itself and does not consider any constraints or the bundle’s class path (Bundle-ClassPath header).”

详见http://www.eclipse.org/forums/index.php/m/710032/#msg_710032

FileLocator

在上文已经提到FileLocator的toFileUrl(String)方法，FileLocator是一个工具类，其目的就是在Bundle中查找相应的资源文件，其本身定义了如下几个方法：

static URL find(Bundle bundle, IPath path, Map override);
static URL find(URL url);
static URL[] findEntries(Bundle bundle, IPath path);
static URL[] findEntries(Bundle bundle, IPath path, Map override);
static File getBundleFile(Bundle bundle);
static InputStream openStream(Bundle bundle, IPath file, boolean substituteArgs);
static URL resolve(URL url);
static URL toFileURL(URL url);

看起来和Bundle中的方法那么的相似，归根结底，FileLocator中的方法也都是通过调用Bundle中的相对应方法来实现其功能的，除了resolve(URL)和toFileURL(URL)，后者之前演示过其功能，前者的功能也同样是将OSGi环境中的URL解析成为文件系统中的URL。其实我不认为此FileLocator除去toFileURL()此方法外地其他方法有更好的地方，如果可能，还是直接用Bundle的方法更好。

总结

很明显，在Bundle中查找文件资源需要通过FileLocator和Bundle两个类的协作才能完成，由于一般情况下Eclipse RCP的属性以及配置值存放于Eclipse Workspace中，从Bundle中读取资源的需求比较少。最主要的应用场景是，一些图片资源可以通过此方式读取，然后在Eclipse RCP应用中处理和显示。

关于Eclipse RCP开发的其他文章：

1. Eclipse RCP 中 Part 和 Site、菜单和工具栏
2. Eclipse RCP开发中关于Image(图片)的API使用
3. Eclipse RCP中的日志

本文是本博客原创文章，您可以自由转载，但转载请注明来源。

<全文完>

在进行 Eclipse RCP 开发的时候，由于 GUI 系统和 Eclipse 平台本身的复杂性，让我们很难理顺各种组件之间的关系，本文对 Eclipse RCP 的 GUI 组成结构进行分析，解释了 Workbench，Workbench Window，Workbench Page，Workbench Part，View Part 和 Editor Part 以及其相互之间的关系。并对和上述组件关系紧密的形如 I**Site 的类（包括 IWorkbenchSite，IWorkbenchPartSite，IPageSite，IViewSite，IEditorSite）进行了分析。
本文最后给出了一个在自定义 View 中加入上下文菜单、工具栏和下拉菜单的示例。

本文的全文PDF文件请点击《Eclipse RCP 中 Part 和 Site、菜单和工具栏》下载

本人撰写的其他Eclipse RCP文章：

1. Eclipse RCP中的日志
2. Eclipse RCP开发中关于Image(图片)的API使用

本文是本博客原创文章，您可以自由转载，但转载请注明来源。

将配置信息写在文本文件中，使用bash一行一行的读取文本文件，然后执行相应的操作，是非常常见的需求，本文使用了shell脚本的while循环和read命令非常简单的达到了目的

其实我的目标是用git下载Eclipse的源代码，Eclipse的源代码是用CVS管理的，会自动同步到Eclipse的git仓库，仓库地址为：http://dev.eclipse.org/git/index.html。

我复制了git仓库的url到一个文本文件urls中，一行一个：

http://dev.eclipse.org/git/org.eclipse.pde/apitools.git

http://dev.eclipse.org/git/org.eclipse.pde/build.git

http://dev.eclipse.org/git/org.eclipse.pde/doc.git

http://dev.eclipse.org/git/org.eclipse.pde/ds.git

http://dev.eclipse.org/git/org.eclipse.pde/org.eclipse.pde.releng.git

http://dev.eclipse.org/git/org.eclipse.pde/ua.git

http://dev.eclipse.org/git/org.eclipse.pde/ui.git

http://dev.eclipse.org/git/org.eclipse.pde/visualization.git

然后想办法读取这个文本文件，执行git clone命令：

cat urls | while read line; do git clone ${line}; done

上面的命令其实是四条命令，

1. cat urls是第一条，将文本文件中的内容输出到标注输出，urls是文本文件名称；
2. while read line是第二条，循环读取标准输入，存放到line变量中，read命令请见参考1；
3. do git clone ${line}是第三条，克隆git仓库到本地文件夹中，git默认为将“xxx.git”中的“.git”去掉，取“xxx”作为克隆项目的目录名称，关于git请见参考3；
4. done是第四条，标示while语句的结束

如果两条命令写在同一行则需要用;号隔开，一行只写一条命令就不需要写;号了。while后面的子命令通常是测试命令，在本例中，读取文件结束，read返回0，循环结束。关于shell请见参考2。

ls -d */ | while read line; do cd ${line}; git pull origin master; cd ..; done

在克隆了git仓库后，还需要执行“git pull”命令更新仓库，仿照上例即可写出上面的代码。

“ls -d */”输出当前文件夹下的文件夹名称，虽然在控制台里面看起来输出在一行，但是实际上用下面的命令就会发现其实每个文件夹名称都是在单独的一行的，关于wc请见参考4。

ls -d */ | wc -l

参考：

1. read MAN Page
2. Shell脚本语法
3. Git Magic 中文版
4. wc MAN Page

Java播放音乐比较麻烦，主要原因是Java的跨平台导致。Java的播放音乐的API主要包括两部分，一是Java SE里面包含的Java Sound API，二是作为独立于Java SE之外的Java Music Framework。两者的主要差别在于所支持的声音文件格式不同。

本文只是对相关技术进行了简单罗列，收集了相关的链接地址，需要深入了解请进入相关链接深入阅读。

Java平台提供的sound API
支持的音频文件格式只有AIFF，AU，WAV
支持的音乐文件格式有MIDI，RMF(Rich Music Format)
声音格式：8位和16位单声道以及立体声音频数据，采样率在8khz和48khz之间

• Java sound api简介
• JavaTM Sound Programmer Guide
• Java Sound API: Java Sound Demo

使用第三方的库播放MP3格式的音乐
How to Play an MP3 File in Java：JLayer MP3 Library

使用Java Music Framework播放MP3格式的音乐

1. Java Game Programming: Playing Sound：该文中介绍了如何使用Java Media Framework播放MP3格式的音乐
2. JMF主页
3. JMF现在的最新版本为2.0，API下载地址

JMF播放MP3示例代码：请把音乐放到Eclipse工程目录的跟目录下（和src目录同级别）

package com.zhlwish.javasound;
 
import java.io.File;
import java.io.IOException;
import java.net.URL;
import javax.media.*;
 
public class Main {
 
    private Player player;
 
    public static void main(String[] args){
        Main m = new Main();
        m.play("可惜不是你.mp3");
    }
 
    public void play(String fileName) {
        try {
            File file = new File(fileName);
            URL url = file.toURI().toURL();
            MediaLocator locator = new MediaLocator(url);
            player = Manager.createPlayer(locator);
            player.addControllerListener(new ControllerListener() {
                public void controllerUpdate(ControllerEvent event) {
                    if (event instanceof EndOfMediaEvent) {
                        player.stop();
                        player.close();
                    }
                }
            });
            player.realize();
            player.start();
        } catch (NoPlayerException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
}

Java播放MIDI实例代码：

AudioPlayer mgp = AudioPlayer.player;
AudioStream bgm;
AudioData md;
ContinuousAudioDataStream loop = null;
 
try{
    bgm = new AudioStream(new FileInputStream());
    md = bgm.getData();
    loop = new ContinuousAudioDataStream (md);
}catch(Exception e){
    e.printStackTrace();
}
 
mgp.start(loop);

2011-7-28更新：

JMF在某些联想(Lenovo)的机器上安装失败，不清楚具体原因，而且JMF已经年久失修，不推荐使用。
最新推荐的是本文中曾提到，但是一笔带过的一个库（内疚中…）,叫JLayer，里面自带两个后台播放器实现Player和AdvancedPlayer，具体的使用方法可以参考http://www.youtube.com/watch?v=f-7cgX_I220

我摘抄了部分代码如下：

File file = new File("xxx.mp3");
FileInputStream fInputStream = new FileInputStream(file);
Player p = new Player(fInputStream);
p.play();

Eclipse RCP开发中的Image API分为两个层次，一个是SWT层，另一个是JFace层面的。

SWT层面的API中的类主要包括Image，ImageData和ImageLoader三个，JFace层面的API中的类主要包括ImageDescriptor和ImageRegistry。

本文的全文PDF文件请点击《Eclipse RCP开发中关于Image(图片)的API使用》下载

完成Eclipse RCP平台日志功能是核心接口为：org.eclipse.core.runtime.ILog

org.eclipse.core.internal.runtime.Log实现了该接口，主要方法如下：

构造函数：

public Log(Bundle plugin)

方法：

public void log(final IStatus status)

一般情况下插件的Activator继承自AbstractPlugin，也间接继承自Plugin，org.eclipse.core.runtime.Plugin中定义了:

public final ILog getLog()

通过该方法直接返回ILog实例，如果当前插件中没有ILog实例，则创建一个新的实例返回

另一个相关的接口是org.eclipse.core.runtime.IStatus，org.eclipse.core.runtime.Status类实现了这个接口，其构造函数如下：

public Status(int severity, String pluginId, int code, 
               String message, Throwable exception)

其中：

1. severity为消息级别，在IStatus中有定义
2. pluginId为插件实例的ID
3. code为消息类型编码，一般为IStatus.OK，各个Plugin可以自行定义status code
4. message为消息内容
5. exception为异常实例，可以为null

示例：

import org.eclipse.core.runtime.ILog;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
public class LogUtils {
 
    public static void logInfo(String message) {
        log(IStatus.INFO, IStatus.OK, message, null);
    }
 
    public static void logError(Throwable exception) {
        logError("Unexpected Exception", exception);
    }
 
    public static void logError(String message, Throwable exception) {
        log(IStatus.ERROR, IStatus.OK, message, exception);
    }
 
    public static void log(int severity, int code, String message,
            Throwable exception) {
        log(createStatus(severity, code, message, exception));
    }
 
    public static IStatus createStatus(int severity, int code, String message,
            Throwable exception) {
        return new Status(severity, Activator.PLUGIN_ID, code, message,
                        exception);
    }
 
    public static void log(IStatus status) {
        ILog log = Activator.getDefault().getLog();
        log.log(status);
    }
}

本文是本博客原创文章，您可以自由转载，但转载请注明来源。

很受启发的一篇文章，作者：天则经济研究所 茅于轼

卡扎菲很爱他的人民，这是毫无疑问的。他把国家石油收入的大部分用于百姓的福利。全国百姓都享受免费医疗，甚至出国看病的费用也能报销，而且住房不要钱。百姓生活得很满足，而且一年比一年好。他爱百姓，可是百姓不领情，还要造他的反。卡扎菲百思不得其解。最后他找到的答案是西方国家在幕后煽动，否则这事绝不可能发生。

这是一切独裁者的共同思维方式。他们不但把政府的收入大部分用于百姓的福利，而且昼夜操心，为百姓谋幸福，为捍卫国家的主权独立而奋斗，还为百姓之间的纠纷主持公道。他们如此关心百姓，理应受到百姓的爱戴。现在百姓忽然要造反，对他们来讲非常不可思议。现在的独裁者并不是只顾个人享受的帝王将相，他们不是低级趣味的人，而是有理想的人，是负责任的人。当然他们也不是理想的君子，思想很复杂。但是他们的确是为人民服务的。卡扎菲很有把握地说，他受到人们的拥护和爱戴。这是他的真心话。他这样忠心耿耿为人民，现在人们反而造起反来了，他完全无法接受。最后他判断完全是西方敌对势力的所作所为。外面人往往以为，说造反派是受了境外敌对势力的煽动，完全是无中生有，是故意歪曲，恶意栽赃。其实并非如此，独裁者不是故意栽赃，他们真是这样想的。不光是卡扎菲，大多数的独裁者都是这样想问题的，因为找不到别的理由。可是他们得出了远离实际的答案。造反是完全自发的，和外国人无关。

正因为卡扎菲深信人民是爱他的，所以当有人反对他时他对这些忘恩负义的人格外痛恨，必欲除之而后快。所以手段特别狠毒，不惜下毒手杀人。不光是卡扎菲如此，一切独裁者对待民间的反政府力量都如此。他们认为杀掉的都是坏人，至少也是不知好歹的被坏人利用的人，所以毫不手软。

这是值得我们深思的问题，为什么为人民服务而得不到好报？为什么民间反政府人士认为自己是从事正义和高尚的事业，而独裁者认为这些人是忘恩负义，无理取闹，或被人利用。

我认为这里的原因是统治者对国家治理性质的误解。他们不懂得，正如我国宪法上写的“一切权力属于人民（宪法总纲第二条）”，人民才是国家的主人。统治者只不过是受人民委托临时管理国家的。卡扎菲不懂得，石油本来不属于他的，而属于全体人民的。他无权决定石油收入该如何分配。之所谓给百姓的恩施本来就是人民应该得到的。他未经百姓同意而私自占有的那部分实际上是贪污了百姓的财产。这样的认识和卡扎菲的认识完全是对立的。判断的绝然相对立，焉能不发生冲突。

统治者更不懂得人与人平等的人权观念，自以为统治者高人一等，百姓只能听他摆布，不许可有任何自由平等的想法。如果想要和统治者平起平坐，那就是大逆不道。尤其是绝不允许百姓选择别的统治者，铁打的江山要千秋万代传下去。自己死了由儿子接班。从秦始皇开始，天下的独裁者无一例外。

统治者的野心越来越大，不但不许百姓越轨行动，连类似的想法都是绝对不容许的。所以在这些国家里都关押着良心犯。他们并非存心反政府，只是要求自由平等。可是独裁者决不允许任何人和自己有平等地位，他们把自己塑造成超人的形象，是真理的发现者甚至能够创造真理，是真理的化身。他们的话就是教科书，一开口就是百姓学习的材料，而且他们的讲话就是法律。毛泽东有红宝书，卡扎菲有绿宝书，都是教百姓如何做人的。他们进而想统治百姓的思想，防止妖言惑众，搞出版审查制。于是和百姓的冲突越来越频繁，不知不觉变成了广泛的社会冲突。中国古代的皇帝都认为天下都是自己的，每一寸土地他都有权支配，任何一个老百姓他都有权指挥。现代的独裁者也这样想问题。

百姓起来造反，在独裁者看来是破坏国家安定，绝对不利于国家和百姓，要把他们消灭于萌芽状态。但是消灭不了，形势越来越严重。于是维稳压倒一切，别的统统都被压倒了。法律的尊严，社会的正义，都得让位于稳定。社会的扭曲越来越严重，维稳越来越困难，倾全国之力还觉得不够。维稳以百姓为对象，有庞大的队伍，充足的预算（来自于百姓的纳税）。这些人拿了政府的待遇，当然要为政府做事。首先是寻找可疑的敌人，结果把本来不是敌人的人也看做可疑分子，限制他们的自由。维稳到此不但没稳定，反而增加了敌对情绪。弄得风声鹤唳，手忙脚乱。结果就是进一步增加维稳的力量和经费，增加维稳的人员，形成正反馈，越搞越紧张。政府靠自我绕不出去，陷入恶性循环。

独裁者始终不明白，现在百姓要的主要不是生活福利，而是平等自由。利比亚人民生活并不差，他们缺的是人权。也有些学者认为利比亚动乱是地缘政治造成的。所谓地缘政治就是各大强国在当地瓜分势力范围。这一说法非常牵强附会。参与游行的百姓根本不懂什么地缘政治。他们自觉参与到游行队伍中，是因为自身的感受，是因为人权得不到保障。参与游行也不是因为生活问题。中国人改革以来的生活改善，其速度超过世界上任何一个别的国家。现在中国政府以为改善民生可以缓解社会矛盾，所以下一个五年规划以民生为重点，而忽视政治改革。这样一条路很可能是看错了方向。

独裁者还把国家看得至高无上，因为他们代表着国家。国家至高无上，其实就是他们自己至高无上。至于百姓，那是无所谓的。所以在他们的眼里主权高于人权。为了主权可以牺牲人权。国家如果受威胁，必要时可以无视人权。这次利比亚动乱，国家受到威胁。这个威胁来自反对派的百姓。为了消除对国家的威胁，可以消灭参与动乱的分子。所以卡扎菲动用军队杀死参与反政府活动的百姓，从而引起国际干涉，联合国通过决议在利比亚设禁飞区。禁飞区显然侵犯了国家的主权。为了保护人权，国际社会有权这样做。其理由就是人权高于主权。国家的主权之所以重要，因为它可以保护人权，抵抗外来的侵犯。反过来，如果这个主权自己就侵犯人权，要这样的主权有什么用。

在卡扎菲的眼中，联合国设禁飞区的决定正是西方在背后煽动的证据。西方国家先是煽动百姓造反，最后亲自出马干涉内政。拿这一点来看，卡扎菲是有道理的。人权思想，自由平等思想都渊源于西方。抵制西方思想的侵袭是许多东方国家领导人的目标。现在世界上的独裁国家都不在西方，都在逐渐西化的东方国家里。于是意识形态的冲突在所难免。可是最近发生在伊斯兰国家里一连串的事件说明，人权思想的确是普世价值。不论东方西方，也不论是什么宗教信仰都认可人权。这是大势所趋，不可阻挡。连中国也不得不对设置禁飞区投了弃权票。因为否认人权，把主权看得高于一切，为了主权国家有权屠杀百姓，实在是说不过去的。不过在中国几千年的皇权历史中，任何反对皇权的人都要被灭三族，杀个精光。现在跟随世界潮流，这种认识已经基本上被否定。这是我们政治上的巨大进步。

利比亚的事态还在发展中，结果如何还很难说。追求人权未必能够得到人权。搞得不好反而会破坏人权。如果利比亚陷入内战，双方都说为人权而战，长期流血冲突，国家陷于分裂，最遭殃的就是百姓。如何避免这种结果，双方都要有妥协和让步的思想准备。要真正把人民的利益放在最重要的位置上来考虑，党派的利益要退居人民利益之后。可惜的是理性往往不能战胜情绪，事情的发展不以人们的意志为转移。国家被拖入对一切人都不利的状态也完全有可能。

最近Gmail总是时断时续，实在是受不了，只能/翻/墙/，我真得被逼的，尼玛！

GAppProxy + Firefox + AutoProxy是不可多得的/翻/墙/利器，对一般的用户来讲虽然设置起来还是比较麻烦的，不过对于俺们程序猿来讲这个都不会弄就不用做程序猿：http://code.google.com/p/gappproxy/wiki/GAppProxy_2_0_0_Manual。

在Ubuntu上，每次启动都需要在Terminal里面执行python proxy.py就可以运行，不过需要一直开着Terminal，这个很不爽，而且每次都需要执行两条命令（一条cd，一条python），比较麻烦。

于是尝试了一下，开机自动启动GAppProxy的办法如下：

1. 用VIM打开~/.profile

vim ~/.profile

2. 在最后加上：

cd /opt/gappproxy/localproxy
nohup python proxy.py  &
cd ~

注意，在最后要加上&哟
nohup是表示关掉shell后不关闭在后台执行的程序。

为什么会出现这样的问题不清楚，只能祭出终极解决办法，重装Chrome。

sudo apt-get remove chromium-browser
sudo apt-get install chromium-browser

重装之后问题依旧，想想配置文件没有删掉吧，可能是这个问题，Chrome的配置文件位置：~/.config/chromium，删掉即可

sudo apt-get remove chromium-browser
rm -rf ~/.config/chromium
sudo apt-get install chromium-browser

Ubuntu默认使用GNOME作为桌面环境，Nautilus是GNOME下默认的文件浏览器，我想在Nautilus的右键菜单中添加“Open Terminal Here“或者”Open in Terminal“这样的菜单，在文件浏览器中直接点击右键菜单即可在打开Terminal并且cd到当前目录。

nautilus-open-terminal是Nautilus的一个扩展，可以达到前文描述的功能。

安装如下：

sudo apt-get install nautilus-open-terminal

安装完成后，有人说需要重启电脑，其实不用，只需要kill掉进程，然后打开文件浏览器nautilus就可以了

killall -9 nautilus

参考：

• open terminal here
• nautilus-open-terminal : terminal quick launch
• How to open a menu with ‘Open Terminal Here’ in Ubuntu 10.04 by left clicking desktop, or inside folder?
• 中文man手册:killall – 以名字方式来杀死进程
• kill 参数中信号名

原文来自这里Bash Shell Shortcuts和这里Bash Shell 快捷键的学习使用，但是归根结底，还是来自这里Bash Shell Shortcuts，我只是稍微翻译了一下，重新排了序

Ctrl系

Ctrl + a - 光标跳转到命令的开头（当命令敲完了，结果发现开头敲错了的时候用）
Ctrl + e - 光标跳转到命令结尾
Ctrl + b - 光标往左移动一个字符
Ctrl + f - 光标往右移动一个字符
Ctrl + x + x - 光标移动到最后和当前位置两个地方跳转

Ctrl + d - 删除光标所在位置的字符
Ctrl + h - 删除光标所在位置之前的一个字符
Ctrl + k - 删除光标所在位置之后（右边）的所有字符
Ctrl + u - 删除光标所在位置之前（左边）的所有字符 （密码输入错误的时候比较有用）
Ctrl + w - 删除最后输入的单词 

Ctrl + c - 终止正在执行的命令
Ctrl + z - 挂起/停止正在执行的命令

Ctrl + l - 清屏，类似 clear 命令
Ctrl + r - 查找之前执行过的命令

Ctrl + y - 在当前光标处插入之前输入的命令 （有用）

Alt系

Alt + < - 显示历史命令中的第一条 （咱中文用户就不用试了，和输入法切换冲突）
Alt + > - 显示历史命中中的最后一条
Alt + ? - 显示命令不全的候选项
Alt + * - 插入命令不全的所有候选项
Alt + / - 补全文件（夹）名称
Alt + . - 插入前一个命令的最后一个参数 （这个很好很强大）
Alt + b - 光标往左移动一个单词
Alt + f - 光标往右移动一个单词（诶，和显示菜单的快捷键冲突了）
Alt + c - 将光标所在的字符变成大写
Alt + d - 删除光标所在位置的单词

Alt + l - 将单词中光标位置之后的字符变成大写
Alt + u - 将单词中光标位置之后的字符变成大写
Alt + t - 在单词中的字符间跳转（诶，和菜单的快捷键冲突了）

Alt + y - 在当前光标处插入之前之前（两个之前，不是我敲错了）输入的命令（请和Ctrl + y比较）

Alt + back-space - 删除光标所在位置之前（左边）的所有字符

其他特定的键绑定
输入 bind -P 可以查看所有的键盘绑定。这一系列我觉得更为实用。
下面的命令中2T表示按两下Tab键

$ 2T - 命令行补全，显示所有候选项
$ (string)2T - 命令行补全，显示以string开头的所有候选项
$ /2T - 显示文件夹中的所有文件，包括.开头的隐藏文件
$ ./2T - 显示文件夹的子文件夹，包括.开头的隐藏文件
$ *2T - 显示文件夹的子文件夹，不包括.开头的隐藏文件
$ ~2T - 显示"/etc/passwd"vs中所有的用户？ （不是很明白这个是干什么用的）
$ $2T - 所有的系统变量
$ @2T - "/etc/hosts"中的所有的项 （依然不明白）
$ =2T - 和ls或者dir输出的一样 （更不明白有了ls，还要这个干嘛，Tab控）

Esc + T - 交换光标前面的两个单词 （这个好玩）

有些不实用的被我直接删掉了，如果需要找的话，参考Readline shortcuts这个把，里面居然有简单的图示。

本文是本博客原创文章，您可以自由转载，但转载请注明来源。

2011年9月23日16:30:54 更新

关于JID，请参考XMPP中资源/Resource的解释和JID

Python有2个package实现了XMPP和Jabber标准：xmpppy和 pyxmpp，哪个好就自然是一个问题。一般公认的看法是pyxmpp是首选，它完全符合XMPP协议，开发也保持活跃的状态，并且最新的版本是2010年发布的。而xmpppy则公认为设计上有不太合理之处，也不完全符合XMPP协议，所以不推荐使用，而且还是在2009年4月份更新的，开源神马的最怕不更新了！

安装

在Ubuntu 10.10上安装pyxmpp有两种办法，一种是一步到位：

sudo apt-get install python-pyxmpp

另一种是自己下载，之后安装，但是由于pyxmpp依赖python-libxml2，python-dnspython，而且在用gtalk发送消息时使用tls加密，因而还依赖python-m2crypto，所以安装过程如下：

sudo apt-get install python-libxml2
sudo apt-get install python-dnspython
sudo apt-get install python-m2crypto

tar -xzvf pyxmpp-1.1.1.tar.gz
cd pyxmpp-1.1.1
sudo python configure.py
sudo python setup.py build
sudo python setup.py install

代码

环境就安装好了，下面是代码：

#!/usr/bin/python
# -*- coding: utf-8 -*-
 
from pyxmpp.jid import JID
from pyxmpp.message import Message
from pyxmpp.jabber.client import JabberClient
from pyxmpp.jabber.simple import send_message
from pyxmpp import streamtls
 
class Gtalk():
    def __init__(self, sid, spwd):
        self.sid = JID(sid)
        self.spwd = spwd
 
    def send_msg(self, rid,  msg):
        self.rid = JID(rid)
        if not self.sid.resource:
            self.sid = JID(self.sid.node, self.sid.domain, 'send_message')
 
        msg = Message(to_jid=self.rid, body=msg)
        def send(stream):
            stream.send(msg)
 
        self.xmpp_do(send)
 
    def xmpp_do(self, function):
        class Client(JabberClient):
            def session_started(self):
                function(self.stream)
                self.disconnect()
 
        tls = streamtls.TLSSettings(require=True, verify_peer=False)
        auth = ['sasl:PLAIN']
        gtalkClient = Client(self.sid, self.spwd, tls_settings=tls, auth_methods=auth)
        gtalkClient.connect()
        try:
            gtalkClient.loop(1)
        except KeyboardInterrupt:
            print u'disconnecting...'
            gtalkClient.disconnect()
 
if __name__ == '__main__':
    g = Gtalk('myaccount@gmail.com', u'mypassword')
    g.send_msg('to@gmail.com', 'message')

将其中的帐号和密码替换过来，就可以直接运行了。

出错

如果出现：raise FatalStreamError,”StartTLS support disabled, but required by peer 这样的错误信息，可能是没有安装Python的M2Crypto包，或者版本太老了吧。

参考

• PyXMPP：A Python Jabber/XMPP implementation.
• Getting Google Talk working with PyXMPP

Windows上Apache+PHP+MySQL的安装配置就不多说了，这篇文章写得不错，全面实用PHP环境搭建:Windows 7下安装配置PHP+Apache+Mysql环境教程

不过我安装好PHP之后，发现Apache启动的时候总是无法加载extention，在log/error.log里面打印一句话：

PHP Warning:  PHP Startup: Unable to load dynamic library

后来把php的安装路径加入到系统环境变量PATH中就解决了这个问题，注意一定是系统环境变量，本人最初是傻不啦叽的加入到用户环境变量的PATH里面，结果不起作用。

经过测试PHP的环境搭建好之后，就可以开始配置CakePHP了，我下载的CakePHP解压后放在E:\Working\cakephp里面，下文多出要用到，特此声明。

首先启动Apache的mod_rewrite，在httpd.conf里面找到下面的语句，在118行左右，去掉最前的注释符号(#)

#LoadModule rewrite_module modules/mod_rewrite.so

然后在httpd.conf的最后加入以下配置：

Alias "/cake" "e:/Working/cakephp"

<Directory "e:/Working/cakephp">
Options FollowSymLinks
AllowOverride All
Order allow,deny
Allow from all
</Directory>

重启Apache后，访问http://localhost/cake出现”The requested URL /Working/cakephp/app/webroot/index.php was not found on this server.”

这时后请在CakePHP目录下的.htaccess里面添加一行”RewriteBase /cake”，添加之后的文件是：

<IfModule mod_rewrite.c>
   RewriteEngine on
   RewriteBase /cake
   RewriteRule    ^$ app/webroot/    [L]
   RewriteRule    (.*) app/webroot/$1 [L]
</IfModule>

然后再访问http://localhost/cake，就可以看到正常的页面的。至于RewriteBase是怎么一回事儿，请参见Apache Rewrite 详解 RewriteBase

最后附上官方的指南http://book.cakephp.org/cn/view/917/Apache-%E5%92%8C-mod_rewrite，其实这个写得很差。

写了个python脚本自动完成某项工作，需要将从命令行读入的参数写到utf-8编码的文件中，在linux系统中没有问题，因为shell默认为utf-8编码格式，读入后直接写入就行，但是由于Window系统的默认编码为cp936，始终提示编码有错误。

import sys
import codecs
 
in_encoding = sys.stdin.encoding
name = raw_input("Input your name:")                   #1
 
with open('1.conf', 'w') as conf:
    conf.write("name=%s" % name)                        #2
 
name = name.decode(in_encoding)                        #3
 
with open('2.conf', 'w') as conf:
    conf.write("name=%s" % name.encode('utf8'))    #4
 
with codecs.open('3.conf', 'w', 'utf8') as conf:
    conf.write("name=%s" % name)                        #5

解释：

1. 为了保证平台无关性，首先使用sys.stdin.encoding取得控制台输入的编码，使用raw_input读入数据
2. 直接使用ANSI编码写入文件，此时生成的文件为ANSI编码格式，中文可以正常显示，但是不符合文件为UTF-8编码的要求
3. 对输入的中文使用控制台的编码进行解码
4. 对解码后的中文字符使用UTF-8编码，此时，输入的文件为UTF-8的格式，满足要求（虽然在open文件的时候没有指定编码，但是生成的文件是UTF-8的编码）
5. 使用codecs模块的open，直接指定输出文件编码，因此不需要decode，可以直接输出UTF-8的字符

精通Java或者.net的同学在学习Python面向对象的时候总会思考一个问题，Python对象的toString()方法怎么写，怎么样才能print一个对象打印出友好的内容，而不是打印出内存地址？比如定义一个类

class Friend():
    def __init__(self, name):
        self.name = name
 
if __name__ == '__main__':
    friend = Friend('Liang')
    print friend

上面这段代码，在我的电脑上输出

<__main__ .Friend instance at 0x7ff3596c>

我想输出我的朋友的姓名不行么？我想要Java的toString()！

其实，可以的，__str__就是toString()，OK，继续完善代码

class Friend():
    def __init__(self, name):
        self.name = name
 
    def __str__(self):
        return "Friend : %s" % self.name
 
if __name__ == '__main__':
    friend = Friend('Liang')
    print friend

终于打印出我想看到的了

Friend name : Liang

显然的，内置函数带来了这种便利，理所当然要有所约束，那就是这个方法只能返回str，并且只能有self这一个参数，其他的，自行发挥，你懂的