我爱ubuntu

skyhorse
2006-7-5

原来都没有听说过ubuntu, 也没有用过, 前2天因为想装一个oracle10G玩玩,本想装redhat advance server的,因为刻的盘有些问题,改装ubuntu 6.06 desktop版, 这才发现ubuntu 的好处, 感觉很开心.

比方说我要装eclipse, 只需一个命令: apt-get install eclipse 网络环境好的话,几分钟之内就在你的桌面的编程菜单中出现 eclipse 了. 你什么也不需要作,鼠标都不用点.如果不愿意敲命令,也有界面可以用.

2天时间内, 装了一堆软件, 这在以前是我不能想象的, 原来总是configure, make, make install, 且还总是少这个包,少那个包的,还不一定成功.

我装了 Oracle 10G ,以及附加的第二张盘的软件(一个包括Ultra Search的冬冬), 安装过程第一张盘没有遇到 link之类的任何错误, 第二张有几个小错误.
当然了,你需要先google 几个oracle 10g的安装文档照着做就行了. 另外dbstart 内部已经启动listener了,所以无需在自启动的脚本中添加启动listener的命令了,还发现了oracle10g的脚本的bug, 呵呵.

还有下面的:
mediawiki(大名鼎鼎的wiki软件), phpmyadmin(mysql管理必备), cvs ,cvsd(一个安全运行cvs pserver的wrapper), apache2, mysql, Mambo(类似xoops的内容发布系统,但是更漂亮), tomcat 总之就是网站的那一套东西.

防火墙(firestarter) 强烈推荐这个, 在界面上简单加几个规则, 你再在终端中 sud iptables -L 一看,简直帅呆了. 作者肯定把iptables 这套东西搞得滚瓜烂熟.  这个可比windowsxp下的自带防火墙功能强大多了, 主要是因为如果你熟悉iptables的话,可以自己写策略执行就可以了, 比方说结合squid作个透明代理, 或者起2个dns,再作一下根据ip来源进行不同端口映射,作个动态的dns. 如果不熟悉的话,就把它当作window下自带的防火墙来用.
我就简单地通过界面加上了 保留 http 的端口,  对 ssh 则加上了网段的限制, 很快也很方便.(如果不会计算子网掩码就自己google一下subnet netmask之类的:) )

还有vnc,连接windows的终端软件, 光盘刻录, 媒体播放(mplayer之类), freemind(一个绘制思维导图软件,java的,也有windows版),其他一些桌面的软件就不用说了, 系统安装时自带的.

顺便说下, 因为firefox 的linux版不带导入ie的功能, 所以我在windows版的firefox中导出ie的收藏夹, 它存成了一个html文件,然后在linux 下用书签管理导入这个文件就可以了.太帅了.

系统启动时默认就是能够挂载windows分区的, 桌面也非常漂亮, 我用右键把菜单中的常用的几项加到了panel上, 如终端,文件管理器. 屏保也非常炫,比windows的那种中规中矩的好看多了.

同时也有很多有趣的游戏.

总结了一下ubuntu 的优点:
软件包的维护和依赖关系的计算非常好, 大大方便了软件的安装, 知道软件名字直接下载就行了, 连菜单的类别都创建好了.
有一个巨大的维护的软件库. 你可以选择离你最近的站点.( 我用的是 mirror.net9.org )
通过默认的 sudo 来保证了系统的安全. ( 如果有人奇怪安装后root密码是什么,可以参加wikt.ubuntu.org.cn上的常见问答)

界面比较容易上手,也很方便. 一般的用户往往都是装了一个linux,发现不好用,就放弃了, 我相信随着ubuntu的发行,这个情况应该逐渐会有所改观.
本来电脑的目的就是为了更方便快捷地帮助人们解决各自的问题的, 可用性增强了,自然会吸引大批用户.

不过我也遇到点小问题, 自动装bugzilla的时候, 创建mysql的数据库表时出错, 看来,需要自己来安装配置了.

顺便说一下我的这台电脑是在实验室同时用来给自己提供服务,开发和做桌面用的.
你也可以选择安装不带gui的server版.

从 apt-get , sudo 都不知道是什么命令,到安装配置我的电脑的各类软件,我只用了2,3天时间, 多亏了 ubuntu, google和那些写文章的linuxer们.
所以写了这么一篇宣传一下:), 希望更多的人使用. 这也符合ubuntu的共享精神.
使用ubuntu即享受桌面的乐趣,又享受自己diy的乐趣, 更重要的是它是开源和免费的.

btw: 用google trends 搜一下, ubuntu 也是一直处于上升的趋势.

wiki.ubuntu.org.cn 上的 新手入门指引  提供了大量的帮助, 请一定要仔细看,并照做,相信你一定会很快上手的.

http://www.opinmin.com/

http://www.wefeelfine.org/

S[+inv]->(AUX AGR ?a SUBCAT ?v)(NP AGR ?a)(VP VFORM ?v)
应该改为:
S[+inv]->(AUX AGR ?a COMPFORM ?v)(NP AGR ?a)(VP VFORM ?v)

这是我在写程序,试验那些语法规则时发现的.

原版和翻译版本(p107)都是如此.

希望大家有时间写程序验证一下.

尽管去掉了多余的垃圾边,还是有这么多,呵呵.果然是一件麻烦的事情.

1 can 2
ACTIVE_ARCS:
(S INV:- VFORM:? pres past AGR:?) --> o (NP AGR:?) (VP VFORM:? pres past AGR:?) (1,1)
(NP AGR:?) --> o (PRO AGR:?WH:?) (1,1)
(NP AGR:?) --> o (ART AGR:?) (N AGR:?) (1,1)
(NP AGR:?) --> o (NAME AGR:?) (1,1)
(NP AGR:?WH:?) --> o (DET AGR:?WH:?) (CNP AGR:?) (1,1)
(DET AGR:?WH:?) --> o (QDET WH:?) (1,1)
(S INV:+ VFORM:?AGR:?WH:?GAP:?) --> o (AUX AGR:1s 2s 3s 1p 2p 3p COMPFORM:base ) (NP AGR:1s 2s 3s 1p 2p 3p WH:?GAP:(- ) ) (VP VFORM:base AGR:1s 2s 3s 1p 2p 3p GAP:?) (1,1)
(S VFORM:?AGR:?) --> o (NP AGR:?WH:Q GAP:(- ) ) (S INV:+ VFORM:?AGR:?GAP:(NP ) ) (1,1)
(NP AGR:?) --> o (PRO AGR:?WH:?) (1,1)
(NP AGR:?) --> o (ART AGR:?) (N AGR:?) (1,1)
(NP AGR:?) --> o (NAME AGR:?) (1,1)
(NP AGR:?WH:?) --> o (DET AGR:?WH:?) (CNP AGR:?) (1,1)
(DET AGR:?WH:?) --> o (QDET WH:?) (1,1)
(S INV:+ VFORM:pres AGR:1s 2s 3s 1p 2p 3p WH:?GAP:?) --> (AUX AGR:1s 2s 3s 1p 2p 3p COMPFORM:base ) o (NP AGR:1s 2s 3s 1p 2p 3p WH:?GAP:(- ) ) (VP VFORM:base AGR:1s 2s 3s 1p 2p 3p GAP:?) (1,2)
(NP AGR:?) --> o (PRO AGR:?WH:?) (2,2)
(NP AGR:?) --> o (ART AGR:?) (N AGR:?) (2,2)
(NP AGR:?) --> o (NAME AGR:?) (2,2)
(NP AGR:?WH:?) --> o (DET AGR:?WH:?) (CNP AGR:?) (2,2)
(CNP ) --> o (N AGR:?) (2,2)

CONSTITUENTS:
(AUX VFORM:pres AGR:1s 2s 3s 1p 2p 3p COMPFORM:base )(1,2)

AGGENDA:

1 can 2 he 3
ACTIVE_ARCS:
(S INV:- VFORM:? pres past AGR:?) --> o (NP AGR:?) (VP VFORM:? pres past AGR:?) (1,1)
(NP AGR:?) --> o (ART AGR:?) (N AGR:?) (1,1)
(NP AGR:?WH:?) --> o (DET AGR:?WH:?) (CNP AGR:?) (1,1)
(S INV:+ VFORM:?AGR:?WH:?GAP:?) --> o (AUX AGR:3s COMPFORM:base ) (NP AGR:3s WH:?GAP:(- ) ) (VP VFORM:base AGR:3s GAP:?) (1,1)
(S VFORM:?AGR:?) --> o (NP AGR:?WH:Q GAP:(- ) ) (S INV:+ VFORM:?AGR:?GAP:(NP ) ) (1,1)
(NP AGR:?) --> o (ART AGR:?) (N AGR:?) (1,1)
(NP AGR:?WH:?) --> o (DET AGR:?WH:?) (CNP AGR:?) (1,1)
(S INV:+ VFORM:pres AGR:1s 2s 3s 1p 2p 3p WH:?GAP:?) --> (AUX AGR:3s COMPFORM:base ) o (NP AGR:3s WH:?GAP:(- ) ) (VP VFORM:base AGR:3s GAP:?) (1,2)
(NP AGR:?) --> o (PRO AGR:3s WH:?) (2,2)
(NP AGR:?) --> o (ART AGR:?) (N AGR:?) (2,2)
(NP AGR:?) --> o (NAME AGR:?) (2,2)
(NP AGR:?WH:?) --> o (DET AGR:?WH:?) (CNP AGR:?) (2,2)
(CNP ) --> o (N AGR:?) (2,2)
(S INV:+ VFORM:pres AGR:3s WH:?GAP:?) --> (AUX AGR:3s COMPFORM:base ) (NP AGR:3s WH:?GAP:(- ) ) o (VP VFORM:base AGR:3s GAP:?) (1,3)
(VP VFORM:?AGR:?) --> o (V VFORM:?AGR:?SUBCAT:_none ) (3,3)
(VP VFORM:?AGR:?) --> o (V VFORM:?AGR:?SUBCAT:_vp:inf ) (VP VFORM:inf ) (3,3)
(VP VFORM:?AGR:?) --> o (AUX COMPFORM:?) (VP VFORM:?AGR:?) (3,3)
(VP VFORM:?AGR:?PASSGAP:- ) --> o (V SUBCAT:_np ) (NP AGR:?) (3,3)
(VP VFORM:?AGR:?PASS:+ ) --> o (AUX :be ) (VP VFORM:pastprt PASSGAP:+ ) (3,3)
(VP VFORM:?AGR:?PASSGAP:+ ) --> o (V SUBCAT:_np ) (3,3)
(VP VFORM:?AGR:?GAP:?) --> o (V SUBCAT:_np ) (NP AGR:?GAP:?) (3,3)

CONSTITUENTS:
(AUX VFORM:pres AGR:1s 2s 3s 1p 2p 3p COMPFORM:base )(1,2)
(PRO AGR:3s )(2,3)
(NP AGR:3s ) --> (PRO AGR:3s WH:?) o (2,3)

AGGENDA:

1 can 2 he 3 see 4
ACTIVE_ARCS:
(S INV:- VFORM:? pres past AGR:?) --> o (NP AGR:?) (VP VFORM:? pres past AGR:?) (1,1)
(NP AGR:?WH:?) --> o (DET AGR:?WH:?) (CNP AGR:?) (1,1)
(S VFORM:?AGR:?) --> o (NP AGR:?WH:Q GAP:(- ) ) (S INV:+ VFORM:?AGR:?GAP:(NP ) ) (1,1)
(NP AGR:?WH:?) --> o (DET AGR:?WH:?) (CNP AGR:?) (1,1)
(S INV:+ VFORM:pres AGR:1s 2s 3s 1p 2p 3p WH:?GAP:?) --> (AUX AGR:3s COMPFORM:base ) o (NP AGR:3s WH:?GAP:(- ) ) (VP VFORM:base AGR:3s GAP:?) (1,2)
(NP AGR:?) --> o (ART AGR:?) (N AGR:?) (2,2)
(NP AGR:?WH:?) --> o (DET AGR:?WH:?) (CNP AGR:?) (2,2)
(S INV:+ VFORM:pres AGR:3s WH:?GAP:?) --> (AUX AGR:3s COMPFORM:base ) (NP AGR:3s WH:?GAP:(- ) ) o (VP VFORM:base AGR:3s GAP:?) (1,3)
(VP VFORM:?AGR:?) --> o (V VFORM:?AGR:?SUBCAT:_none ) (3,3)
(VP VFORM:?AGR:?) --> o (V VFORM:?AGR:?SUBCAT:_vp:inf ) (VP VFORM:inf ) (3,3)
(VP VFORM:?AGR:?) --> o (AUX COMPFORM:?) (VP VFORM:?AGR:?) (3,3)
(VP VFORM:?AGR:?PASSGAP:- ) --> o (V SUBCAT:_np ) (NP AGR:?) (3,3)
(VP VFORM:?AGR:?PASS:+ ) --> o (AUX :be ) (VP VFORM:pastprt PASSGAP:+ ) (3,3)
(VP VFORM:?AGR:?PASSGAP:+ ) --> o (V SUBCAT:_np ) (3,3)
(VP VFORM:?AGR:?GAP:?) --> o (V SUBCAT:_np ) (NP AGR:?GAP:?) (3,3)
(VP VFORM:base AGR:?PASSGAP:- ) --> (V SUBCAT:_np ) o (NP AGR:?) (3,4)
(NP AGR:?) --> o (PRO AGR:3s WH:?) (4,4)
(NP AGR:?) --> o (ART AGR:?) (N AGR:?) (4,4)
(NP AGR:?) --> o (NAME AGR:?) (4,4)
(NP AGR:?WH:?) --> o (DET AGR:?WH:?) (CNP AGR:?) (4,4)
(CNP ) --> o (N AGR:?) (4,4)
(VP VFORM:base AGR:?GAP:?) --> (V SUBCAT:_np ) o (NP AGR:?GAP:?) (3,4)
(NP AGR:?) --> o (PRO AGR:3s WH:?) (4,4)
(NP AGR:?) --> o (ART AGR:?) (N AGR:?) (4,4)
(NP AGR:?) --> o (NAME AGR:?) (4,4)
(NP AGR:?WH:?) --> o (DET AGR:?WH:?) (CNP AGR:?) (4,4)
(CNP ) --> o (N AGR:?) (4,4)

CONSTITUENTS:
(AUX VFORM:pres AGR:1s 2s 3s 1p 2p 3p COMPFORM:base )(1,2)
(PRO AGR:3s )(2,3)
(NP AGR:3s ) --> (PRO AGR:3s WH:?) o (2,3)
(V VFORM:base SUBCAT:_np )(3,4)
(VP VFORM:base AGR:?PASSGAP:+ ) --> (V SUBCAT:_np ) o (3,4)
(S INV:+ VFORM:pres AGR:3s WH:?GAP:?) --> (AUX AGR:3s COMPFORM:base ) (NP AGR:3s WH:?GAP:(- ) ) (VP VFORM:base AGR:3s GAP:?) o (1,4)

AGGENDA:

1 can 2 he 3 see 4 the 5
ACTIVE_ARCS:
(S INV:- VFORM:? pres past AGR:?) --> o (NP AGR:?) (VP VFORM:? pres past AGR:?) (1,1)
(NP AGR:?WH:?) --> o (DET AGR:?WH:?) (CNP AGR:?) (1,1)
(S VFORM:?AGR:?) --> o (NP AGR:?WH:Q GAP:(- ) ) (S INV:+ VFORM:?AGR:?GAP:(NP ) ) (1,1)
(NP AGR:?WH:?) --> o (DET AGR:?WH:?) (CNP AGR:?) (1,1)
(S INV:+ VFORM:pres AGR:1s 2s 3s 1p 2p 3p WH:?GAP:?) --> (AUX AGR:3s COMPFORM:base ) o (NP AGR:3s WH:?GAP:(- ) ) (VP VFORM:base AGR:3s GAP:?) (1,2)
(NP AGR:?WH:?) --> o (DET AGR:?WH:?) (CNP AGR:?) (2,2)
(S INV:+ VFORM:pres AGR:3s WH:?GAP:?) --> (AUX AGR:3s COMPFORM:base ) (NP AGR:3s WH:?GAP:(- ) ) o (VP VFORM:base AGR:3s GAP:?) (1,3)
(VP VFORM:?AGR:?) --> o (V VFORM:?AGR:?SUBCAT:_vp:inf ) (VP VFORM:inf ) (3,3)
(VP VFORM:?AGR:?PASSGAP:- ) --> o (V SUBCAT:_np ) (NP AGR:?) (3,3)
(VP VFORM:?AGR:?PASSGAP:+ ) --> o (V SUBCAT:_np ) (3,3)
(VP VFORM:base AGR:?PASSGAP:- ) --> (V SUBCAT:_np ) o (NP AGR:?) (3,4)
(NP AGR:?) --> o (PRO AGR:3s WH:?) (4,4)
(NP AGR:?) --> o (ART AGR:3s 3p 3p 3s ) (N AGR:3s 3p 3p 3s ) (4,4)
(NP AGR:?) --> o (NAME AGR:?) (4,4)
(NP AGR:?WH:?) --> o (DET AGR:?WH:?) (CNP AGR:?) (4,4)
(CNP ) --> o (N AGR:?) (4,4)
(VP VFORM:base AGR:?GAP:?) --> (V SUBCAT:_np ) o (NP AGR:?GAP:?) (3,4)
(NP AGR:?) --> o (PRO AGR:3s WH:?) (4,4)
(NP AGR:?) --> o (ART AGR:3s 3p 3p 3s ) (N AGR:3s 3p 3p 3s ) (4,4)
(NP AGR:?) --> o (NAME AGR:?) (4,4)
(NP AGR:?WH:?) --> o (DET AGR:?WH:?) (CNP AGR:?) (4,4)
(CNP ) --> o (N AGR:?) (4,4)
(NP AGR:3s 3p ) --> (ART AGR:3s 3p 3p 3s ) o (N AGR:3s 3p 3p 3s ) (4,5)
(NP AGR:3s 3p ) --> (ART AGR:3s 3p 3p 3s ) o (N AGR:3s 3p 3p 3s ) (4,5)

CONSTITUENTS:
(AUX VFORM:pres AGR:1s 2s 3s 1p 2p 3p COMPFORM:base )(1,2)
(PRO AGR:3s )(2,3)
(NP AGR:3s ) --> (PRO AGR:3s WH:?) o (2,3)
(V VFORM:base SUBCAT:_np )(3,4)
(VP VFORM:base AGR:?PASSGAP:+ ) --> (V SUBCAT:_np ) o (3,4)
(S INV:+ VFORM:pres AGR:3s WH:?GAP:?) --> (AUX AGR:3s COMPFORM:base ) (NP AGR:3s WH:?GAP:(- ) ) (VP VFORM:base AGR:3s GAP:?) o (1,4)
(ART AGR:3s 3p )(4,5)

AGGENDA:

1 can 2 he 3 see 4 the 5 dog 6
ACTIVE_ARCS:
(S INV:- VFORM:? pres past AGR:?) --> o (NP AGR:?) (VP VFORM:? pres past AGR:?) (1,1)
(NP AGR:?WH:?) --> o (DET AGR:?WH:?) (CNP AGR:?) (1,1)
(S VFORM:?AGR:?) --> o (NP AGR:?WH:Q GAP:(- ) ) (S INV:+ VFORM:?AGR:?GAP:(NP ) ) (1,1)
(NP AGR:?WH:?) --> o (DET AGR:?WH:?) (CNP AGR:?) (1,1)
(S INV:+ VFORM:pres AGR:1s 2s 3s 1p 2p 3p WH:?GAP:?) --> (AUX AGR:3s COMPFORM:base ) o (NP AGR:3s WH:?GAP:(- ) ) (VP VFORM:base AGR:3s GAP:?) (1,2)
(NP AGR:?WH:?) --> o (DET AGR:?WH:?) (CNP AGR:?) (2,2)
(S INV:+ VFORM:pres AGR:3s WH:?GAP:?) --> (AUX AGR:3s COMPFORM:base ) (NP AGR:3s WH:?GAP:(- ) ) o (VP VFORM:base AGR:3s GAP:?) (1,3)
(VP VFORM:?AGR:?PASSGAP:- ) --> o (V SUBCAT:_np ) (NP AGR:3s ) (3,3)
(VP VFORM:base AGR:?PASSGAP:- ) --> (V SUBCAT:_np ) o (NP AGR:3s ) (3,4)
(NP AGR:?) --> o (ART AGR:3s ) (N AGR:3s ) (4,4)
(NP AGR:?WH:?) --> o (DET AGR:?WH:?) (CNP AGR:?) (4,4)
(VP VFORM:base AGR:?GAP:?) --> (V SUBCAT:_np ) o (NP AGR:3s GAP:?) (3,4)
(NP AGR:?) --> o (ART AGR:3s ) (N AGR:3s ) (4,4)
(NP AGR:?WH:?) --> o (DET AGR:?WH:?) (CNP AGR:?) (4,4)
(NP AGR:3s 3p ) --> (ART AGR:3s ) o (N AGR:3s ) (4,5)
(NP AGR:3s 3p ) --> (ART AGR:3s ) o (N AGR:3s ) (4,5)

CONSTITUENTS:
(AUX VFORM:pres AGR:1s 2s 3s 1p 2p 3p COMPFORM:base )(1,2)
(PRO AGR:3s )(2,3)
(NP AGR:3s ) --> (PRO AGR:3s WH:?) o (2,3)
(V VFORM:base SUBCAT:_np )(3,4)
(VP VFORM:base AGR:?PASSGAP:+ ) --> (V SUBCAT:_np ) o (3,4)
(S INV:+ VFORM:pres AGR:3s WH:?GAP:?) --> (AUX AGR:3s COMPFORM:base ) (NP AGR:3s WH:?GAP:(- ) ) (VP VFORM:base AGR:3s GAP:?) o (1,4)
(ART AGR:3s 3p )(4,5)
(N AGR:3s )(5,6)
(NP AGR:3s ) --> (ART AGR:3s ) (N AGR:3s ) o (4,6)
(VP VFORM:base AGR:3s GAP:?) --> (V SUBCAT:_np ) (NP AGR:3s GAP:?) o (3,6)

AGGENDA:(S INV:+ VFORM:pres AGR:3s WH:?GAP:?) --> (AUX AGR:3s COMPFORM:base ) (NP AGR:3s WH:?GAP:(- ) ) (VP VFORM:base AGR:3s GAP:?) o (1,6) (VP VFORM:base AGR:3s PASSGAP:- ) --> (V SUBCAT:_np ) (NP AGR:3s ) o (3,6) (NP AGR:3s ) --> (ART AGR:3s ) (N AGR:3s ) o (4,6)

Parsed OK!

OutLine:
DataStructure & Main Algorithm.
Object oriented.

Note:
A class is denoted as: classname : class{ data, method() }
Usually a dateSturce Collection with relevant methods is named after : xxManager
The Main Class is ChartParser

DataStructure:

Sentence: words[] or class{ string[] word, int spos, init(),length(),next(),curword(), toString() }

Symbol: class{String CAT,ArrayList AGR,ArrayList SUBCAT,ArrayList VFORM; 
Copy() // 注意要完全复制， 用Clone会有问题.
boolean NoContrary(Symbol other); // 表示 CAT同，其他实例化的属性不冲突,是包含或相等，非实例化的不管.
// 但是对于Rule中有的，但是C(也就是X)中没有的，则需要只判断C 的所有特征是否都能在Rule.Next中发现，
// 也就是说只用判断 !=null && size()>0的情况
Instantiation(Rule) // 由本Symbol对其他Rule进行空变量的实例化，
}
// Symbol中除CAT外，其他变量的状态表示: size==0表未知，等待实例化; =null 表没有此属性; size==1表已有值,size>1则表示另一种形式的未知，多个值可选,也需实例化.(如果2个都是>1则取交集)
// 这种表示方法的缺陷是: 如果碰到 VP1-> AUX VP补足语 时，VP的VFROM 用AUX的 COMPFORM来表示时，无法表现出2者的关系。
// 可以添加一个专门的变量 equal来表示2者关系, ArrayList of equal; 0=1, 2=3,..
用在Rule中如果

// 按照课本的做法，认为一个单词只有一个CAT,因为其他属性都不一定一样， 多个时，可以用ROOTID之类的来扩展
LexiconWord: class{String word, Symbol sym}
Lexicon: class{HashMap lexicons,LexiconWord getLexiconWord(str); String[] getLexiconWordCat(str) Load()}

Rule: class{Symbol[] thisRule; Symbol getHead(), Symbol[] getBody(), Rule copy() }  // e.g. S -> NP VP
RuleManager class{Rule[] getRightStartWith(String catStr) Load()}

//  0<= rulepos <= rule.length  e.g.  S -> 0 NP 1 VP 2
Arc: class{Rule thisRule; addRule(); int start,end; int rulepos; isFullActive(); isLastPos(); isConstituent(); Arc(rule,start,end,rulepos); Arc(left,right,start,end,rulepos=1) ;
}
isFullActive(): rulepos< thisRule.size()-1; // S-> w1,...C,...Wn-1,Wn
isLastPos(): ruleepos==thisRulesize()-1;   // S-> w1,....C,Wn
isConstituent(): rulepos == thisRule.Size(); //  S->w1,...Wn-1,C  , or C->C

//这里用Stack实现
AggendaManager: class{ArrayList agendaConstiuent; add(), add(Arc), cons Pop(); isEmpty()}

// 这里的ArcManager 包括 ActiveArc 和 Constituent 2种类型的 Arc.
ArcManager: class{ArrayList arcs; ArrayList cons; addArc(); addConstituent() }

ChartParser: class{AggendaManager,ChartManager,Load(), Parser(sentence), extension() extensionStep2(), extensionStep3()}

上面的Arc中的 start, end 分别代表 Sentence的word的位置。
假设n个word组成sentence.
1<= start <= n;
1 < end <= n+1;
注意: word[i] 中的i 则是按照java的数组下表从 0 -->n-1

      而Rule的开始位置是从 0 到 rule.length.
//为了统一处理，将Rule的 Head和Body 都放到一个Symbol数组中了,所以对于rulepos来说，访问body的0位置等于现在访问 Symbol[1]了，
为了不影响原来的程序，getHead(), getBody(),
getBody(rpos) // 内部将rpos+1,取Symbol[rpos+1];
// 或者等程序写完了，统一将 rpos 的值都+1, 按照1---Symbol.length的范围来处理.

Agenda中存已经完成的Constiuent.同时也是要处理的.
Chart包括 Arc 和 Constiuent两部分，与原来写的bottom-up 不一样，把Arc和Constituent用Arc类型统一来处理了。
extension算法得到新的 Active Arc 以及匹配完成的Constiuent 分别加入到Arc和Agenda中。
每次Parser循环时，把单词向后移一位，然后从Agenda中取出一个来。处理完agenda中的所有Constiuent后才再取单词。
对于一个单词的词性 Arc的形式是: N -> N o ( start,end)
算法中的ArcManager 和ConstituentManager都是 ArcManager类型的类,都用来存储Arc，

这里是一步一步地处理。每步把此步的单词词性以及派生出来的成分处理完.

// 弧导入算法,为了便于处理，没有传入一个Arc,而是传入Arc.Rule, arc.end, arc.rule.rulepos,以便当一个单词词性的弧导入时，方便写传入参数.
// arc.start 用不到，所以就省去了。
// 第一次时， S -> NP VP , 1 , 0
//递归导入新弧, 分别传入 这条弧的规则Rule, 这条弧的结束位置arcEnd, 以及规则进行到了第几个位置rpos
// S -> C1 ... o Ci ...Cn  (start,end) =====> Ci -> o X1 X2...Xk ( end, end )
//             rpos                                 0
ArcIntroduction(Rule newRule,int arcEnd,int rpos)
{
 for(each rule[i]){
    if(rule[i].gethead.CAT.equals(newRule.getRuleBodyConstiuent(rpos).CAT)
       && noContrary() ) // 只需判断 noContrary 即可，因为两者的CAT都不为空.
    { // 这里是导入新弧，下一个单词还未确定，所以无需进行各类属性的判断，只需与Rule中有值属性无冲突即可.
      // 但是为了彻底减少垃圾边，newRule是实例化后的更好.
 Arc arcNew=new Arc(rule[i],arcEnd,arcEnd,0); // 新弧以规则的0位置开始.
 arcManager.AddArc(arcNew);
 if(Symbol.getType(rule[i].body[0])!=Symbol.TERMINAL)
     ArcIntroduction(tmprule,arcEnd,rpos);  // 递归非终结符
    }
 }
}

Main Algorithm:( Inside ChartParser class Parser Method )

// 第一次运行导入所有S的规则:
for(each rule)
  if(rule.left=='S')
  {
    Arc arcNew =new Arc(rule[i],1,1,0);
    arcManager.add(arcNew);
    ArcIntroduction(rule[i],1,0);
  }

Sentence --> word[] or SentenceObj
spos=1;
Constiuent c
While(pos<=word.length){
  // 得到一个单词以及成分.
  if(aggendaManager.isEmpty()){
 if(spos<=length){
  // 这里可以删除那些肯定没用的边
  for(each are)
   if( sentence.spos > arc.end && arc.rule[rpos]==terminal )
     arcManager.remove(thisarc);

  //对于下一个词的多种词性，只添加在当前活动弧的下一个位置上的词性
   sym =lexcion.getLexiconWordCat(words[spos-1]).symbol;
  for(each catstr)
  {
     for(each arc)
     {
        if(arc[j].RuleNextCons==catstr[i] && arc.end==sendten.spos
          && noContrary() ==true )
   // 这里无需复制Symbol.因为词性不会变化
   c = new Arc(sym,sym,spos,spos+1);
   aggendaManger.add(c);
   break;
     }
  }
 }//if(spos
 else{ //栈空，且到了句子末尾，解析失败.
   failed! break;
 }
  }//if(aggendaMan
  //把本次构成的所有成分c处理完.
  while(agendaManger.isEmpty()){
   c=agendaManger.pop();
   //如果执行到弹出的一个成分是S,1-end, 表示解析完成。
   if(c.substar='S' && c.start==1 && c.end= n+1 )
   { succeed! break; }
   //进行弧扩展
   extension()
  }
  spos=spos+1;
}//While
if(succeed)
 out.pirntln("Ok!");

// 弧扩展算法, 两个for可以合并到一起.
extension(){
  // 从待处理表agenda中取出的成分Constiuent放入constiuent.
  constientManger.add(c);
  // 包含以C开头的活动边并不处于末尾位置的边再产生新活动边加入arcManager. 同时进行边导入算法 ArcIntro
  //  S-> w1,...o C,...Wn-1,Wn ===> S-> w1,....C o ...Wn
  //          rulepos                         rulepos+1
  for(each arc in arcManger){
 if(isFullActive && arc.end==c.start && arc.rule[rulepos]==c.rule.left
    && noContrary()
   cRule = arc.Rule.copy();
   c.head.instantiation(cRule);
   arcNew=new arc(cRule,arc.start,c.end,rulepos+1);
   arcManger.addArc(arcNew); 
          // 对于新加入的的弧进行导入新弧, 无论传入arc.thisRule，还是实例化后的cRule， 都可以。因为
          ArcIntroduction(cRule,c.end,arc.rulePos+1);

  }
  // 以C cat结尾的活动边 产生新的完全匹配的成分Constiuent加入到aggendaManager中.
  for(each arc in arcManager){
 if(isinLastPos() && arc.end==c.start && arc.rule[rulepos]==c.cat
    && noContrary())
  {
   cRule = arc.Rule.copy();
   c.head.instantiation(cRule);
   arcNew=new arc(cRule,arc.start,c.end,rule.size());
   agendaManger.addCons(cNew);
 }
  }
}

OutLine:
DataStructure & Main Algorithm.
Object oriented.

Note:
A class is denoted as: classname : class{ data, method() }
Usually a dateSturce Collection with relevant methods is named after : xxManager
The Main Class is ChartParser

DataStructure:

Sentence: words[] or class{ string[] word, int spos, init(),length(),next(),curword(), toString() }

LexiconWord: class{String word, ArrayList catStr}
Lexicon: class{HashMap lexicons,LexiconWord getLexiconWord(str); String[] getLexiconWordCat(str) Load()}

Constiuent: class{String catStr; int start, int end}
Rule: class{String head; String[] body}  // e.g. S -> NP VP
RuleManager class{Rule[] getRightStartWith(String catStr) Load()}

//  0<= rulepos < rule.length
Arc: class{Rule thisRule; addRule(); int start,end; int rulepos; isFullActive(); isLastPos()}
isFullActive(): rulepos< thisRule.size()-1; // S-> w1,...C,...Wn-1,Wn
isLastPos(): ruleepos==thisRulesize()-1;   // S-> w1,....C,Wn

//这里用Stack实现
AggendaManager: class{ArrayList agendaConstiuent; add(), cons Pop(); isEmpty()}

ArcManager: class{ArrayList arcs; addArc()}

ConstiuentManager: class{ArrayList consArr; addCons()}

ChartParser: class{AggendaManager,ArcManager,ConstiuentManager,Load(), Parser(sentence), extension() extensionStep2(), extensionStep3()}

上面的Constiuent和Arc中的 start, end 分别代表 Sentence的word的位置。
假设n个word组成sentence.
1<= start <= n;
1 < end <= n+1;
注意: word[i] 中的i 则是按照java的数组下表从 0 -->n-1

Agenda中存已经完成的Constiuent.同时也是要处理的.
Chart包括 Arc 和 Constiuent两部分，
extension算法得到新的 Active Arc 以及匹配完成的Constiuent 分别加入到Arc和Agenda中。
每次Parser循环时，把单词向后移一位，然后从Agenda中取出一个来。处理完agenda中的所有Constiuent后才再取单词。

与刘群的算法不一样，他是一次全部取出。这里是一步一步地处理。每步把此步的单词词性以及派生出来的成分处理完.
另外刘群是把Constiuent的构成无论是词类Cat还是Arc 都作为Arc来处理了。
而NLP Textbook 上好像为了易于理解没有这么说明算法,缺点是多占用了一点空间。

Main Algorithm:( Inside ChartParser class Parser Method )

Sentence --> word[] or SentenceObj
spos=1;
Constiuent c
While(pos<=word.length){
  // 得到一个单词以及成分.
  if(aggendaManager.isEmpty()){
 if(spos<=length){
   catStrs=lexcion.getLexiconWordCat(words[spos-1]);
  for(each catstr){
   c = new Constiuent(catStr,spos,spos+1);
   aggendaManger.add(c);
  }
 }//if(spos
 else{ //栈空，且到了句子末尾，解析失败.
   failed! break;
 }
  }//if(aggendaMan
  //把本次构成的所有成分c处理完.
  while(agendaManger.isEmpty()){
   c=agendaManger.pop();
   //如果执行到弹出的一个成分是S,1-end, 表示解析完成。
   if(c.substar='S' && c.start==1 && c.end= n+1 )
   { succeed! break; }
   //将成分开头的规则加入弧中。
   MatchedRules=RuleManager.getRightStartWith(c.catStr);
   for(each MatchedRule){
  arc=new arc(rule[i],c.start,c.end,pos=1)
  arcManger.addArc(arc);
   }
   //进行弧扩展
   extension()
  }
  spos=spos+1;
}//While
if(succeed)
 out.pirntln("Ok!");

// 弧扩展算法, 两个for可以合并到一起.
extension(){
  // 从待处理表agenda中取出的成分Constiuent放入constiuent.
  constientManger.add(c);
  // 包含以C开头的活动边并不处于末尾位置的边再产生新边加入arcManager.
  for(each arc in arcManger){
 if(isFullActive && arc.end==c.start && arc.rule[rulepos]==c.cat )
   arcNew=new arc(arc.rule,arc.start,c.end,rulepos+1);
   arcManger.add(arcNew); 
  }
  // 以C cat结尾的活动边 产生新的完全匹配的成分Constiuent加入到aggendaManager中.
  for(each arc in arcManager){
 if(isinLastPos() && arc.end==c.start && arc.rule[rulepos]==c.cat ){
   Constiuent cNew=new Constiuent(arc.rule.head,arc.start,c.end)
   agendaManger.add(cNew);
 }
  }
}

0. 预备知识
 C# namespace -- java package
 object x --- Object x
 enum -- jdk 1.5 support , --> static final int
 java 的一个class 文件存在多个class时，只能有一个是public类型的。
 lock -- synchrionized
 ref -- 地址引用。
  void func(ref xx) --- xxtype func(xx)
     使用时 xx = func(xx);
  当多个ref时，只好用全局变量来实现此效果。

 as xx -- (xx) 强制类型转换。
 string -- String 改变大小写. suggest match case,match whole word then replaceAll.
 ToString() -- toString()
 bool --- boolean
 object --- Object
 Console.WriteLine(str); --- System.out.println(str);
 wait,pulse,pulseall -- wait, notify,notifyall
 strFromList.Trim();  --- strFromList.trim();
 strFragAttr.ToLower().Equals(strSelect.ToLower())
 --- strFragAttr.toLowerCase().equals(strSelect.toLowerCase()
 strSql.Substring(nFromIndex,nWhereIndex-nFromIndex) --- strSql.substring(nFromIndex,nWhereIndex)
 // 分割字符
        String[] s=strTableField.Split(new char[]{'.'}); --- String[] s=strTableField.split("\\.");
 // 判断字符串相等 , 如果在java中 用 ==有时会出现问题。
  str1 == str2  --- str1.equals(str2)

 // 有关foreach转换成 for 循环要这样来转换:
 foreach(ArrayList arr in arrConjunctiveNF) --->
                        for(int j=0;j<=arrConjunctiveNF.size()-1;j++)
                        {
                                ArrayList arr =(ArrayList)(arrConjunctiveNF.get(j));

 array[j]; --- arraylist.get(j);
 array.Count --- array.size();

 Hashtable tableJoinAttributes=Hashtable.Synchronized(new Hashtable());
  --- =new Hashtable(); //Hashtable is synchronized.
  or --- Map m = Collections.synchronizedMap(new HashMap(...));

 PredicateElem e=arr[0] as PredicateElem;  --- PredicateElem e = (PredicateElem)arr[0];

 DictionaryEntry --- Map.Entry
 arr.RemoveAt(i); --- arr.remove(i);
 arr.sort() ---- Collections.sort(arr);

  arrAttr.Add(e.leftOpValue); --- arrAttr.add(e.leftOpValue)

  tableJoinAttributes[leftTable] --- get(leftTable);

 tableJoinAttributes[leftTable]=newArr; ---  this.tableJoinAttributes.put(leftTable,newArr);

 tableJoinAttributes.Contains(leftTable)
 -- tableJoinAttributes.containsKey(leftTable)

 stack.Push() Pop() --- stack.push() pop()

                  foreach(DictionaryEntry entry in this.tableJoinAttributes)
                  {
                          ArrayList arr=entry.Value as ArrayList;
                          this.TrimEqual(arr);
                  }
    ------>
                    Set entrys = tableJoinAttributes.entrySet();
                    Iterator it = entrys.iterator();
                    while(it.hasNext()){
                      ArrayList arr = (ArrayList)((Map.Entry)it.next()).getValue();
                      TrimEqual(arr);
                    }

   又一个例子
                        tableIndexCounts=new Hashtable();
   Foreach(Dictionaryentry Entry In Item.Tableindexs)
   {
    Tableindexcounts[Entry.Key]=(Entry.Value As Hashtable).Count;
   }
   ---->
                            tableIndexCounts=new Hashtable();                           
                            Set entrys =  item.tableIndexs.entrySet();
                            Iterator it = entrys.iterator();
                            while(it.hasNext())
                            {
                              Map.Entry entry = (Map.Entry)it.next();
                              tableIndexCounts.put(entry.getKey(),((Hashtable)entry.getValue()).size());
                            }

   对于HashMap 之类的也可以用2个Iterator 同步访问Key & value.

Class的访问权限：
每个编译单元（文件）仅能有一个public class。即：只能拥有一个由public class所表现的单一public接口。可以拥有许多个支持用的friendly classes（默认的访问权限，不需要任何关键字）。如果生命不止一个public class，编译器会给出错误。
public class的名称必须跟编译单元（文件）名称相同。
编译单元内可以不含任何public class，所以可以任意给定文件名（这个以前不知道）。 

 // 有关实现接口interface的转换
 public class RangeEndPoint:IComparable  --- public class RangeEndPoint implements Comparable
 CompareTo() --- compareTo()

 public class myexample:IComparer
 {  
  public int Compare(object x, object y){}
 }
 --->
 public class myexample implements Comparator{
   public int compare(Object o1, Object o2) {
   //Returns:a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.
     return 0;
   }
   // optional
   public boolean equals(Object obj) {
     return false;
   }
 }

 candidate.Sort(new CompareOfTableHorFrag());
 --->   Collections.sort(candidate,new CompareOfTableHorFrag()); 
 or --->
        TableNameAndJoinInfo[] candidate_convert=(TableNameAndJoinInfo[])candidate.toArray();
        Arrays.sort(candidate_convert,new CompareOfTableHorFrag());

 [Serializable]
 ---> implements Serializable

 // c# 的thread 方法名无所谓
 ThreadClassExec exec=new ThreadClassExec();
 Thread threadListen=new Thread(new ThreadStart(exec.ListenThreadMethod));
 threadListen.Start();
 ---> Thread threadListen=new Thread(new implemtsRunableClass())
 class implemtsRunableClass implements Runable{
 public void run(){
 }}
 threadListen.start();

 int nParentIndex; arrBegin.add(nParentIndex)
 --->
        arrBegin.add(new Integer(nParentIndex));

 dataTable,dataTable.Rows ---> CachedRowSet
 dataTable.Rows.Count ---> dataTable.size()

 DataRow row=this.dataTable.Rows[i];
 ---> java 的5.0 版本的 rowset 不提供row , 只能通过metadata得到列数，再遍历
 ResultSetMetaData rsm= dataTable.getMetaData();
        while(crs_down.next()) {
          System.out.print(" "+crs_down.getObject(1));

  key.GetType()==typeof(string)
  ---> if(key.getClass()==String.class)  
  or --> if(key instanceof String)  但是这个好像有是父类时仍相等的问题。不是完全相等.

 System.Data.DataTable.Clone() ,
 ---->
 CachedRowSet.createCopySchema() ,

 Deep Copy:
 System.Data.DataTable.Copy()
 ----> CachedRowSet.createCopy();

 Thread.CurrentThread.Name
 ---> Thread.currentThread.getName();

Abstract:
本演示文档通过3个常见的Web程序实例，引出了一种基于sql语言的快速Web开发模式解决方案。
每个实例都仅需一行或5－6行代码。在对其已经实现的框架做了简要介绍之后，引出最终实现0行代码的构想。
虽然演示的代码实例是基于kylix，但是按照文中的思想，这套解决方案可以移植到任何语言平台上。
可以极大地加快开发速度，缩短开发周期。

Readers:
如果是这套解决方案的使用者，无需看此篇文档，只需要知道如何写Sql语句和html即可进行页面开发。
如果是要对这套解决方案有关通用API部分进行移植和扩充的开发者，则对其要求是：有一点OO的基础，熟悉Regular Expression,

Comment:
SqlDrivedWebFastDevelopSolution.PPT 是主要的PPT, 另一篇MyAssignment3.PPT则是被引用的一个引子。

work to do：
设计数据库表，用于存储程序用到的sql语句。

database design:
1 program: 1 web module(e.g. cgi or jsp)
1 program include: id,name,path,description
1 sql include: id,content,name,description,type(rowset,singlevalue,selectOptions,etc.)
1 sql---n program
1 program -- n sql

3 tables:
tbl_sql,tbl_program,tbl_progs_sqls

develope web modules:
add sql, add program
mod sql, mod program
delete sql,delete program
add sqls to program

后记:
用正则表达式来进行sql的解析也许不是好办法，对于复杂的oracle的sql语句没法解决，可以用编译原理的分析技术来解决。

2005-3

摘要：

负载均衡建立在现有网络结构之上，它提供了一种有效的方法，用于扩展服务器带宽、增加吞吐量、加强网络数据处理能力、提高网络的灵活性和可用性。本文介绍了负载均衡技术的分类概况以及原理介绍,并详细阐述了第4层交换及其调度算法，通过HTTP URL解析和FTP主动模式、被动模式下的负载均衡介绍了第7层交换技术，并给出了负载均衡解决应用的案例。

关键词： 负载均衡 集群 4层交换 7层交换

Load Balance Techniques

 LI Jun

( Department of Computer Science and Technology, Tshinghua University, Beijing 100084, China)

Email: l-jun04@mails.tsinghua.edu.cn

Abstract: Load balancing leverages the existing networks. Hence is a effective approach for increased throughput and extended server bandwidth , for enhanced network data processing capability , and for further network flexibility and availability. This thesis presents briefly a load balancing theory , components. then use HTTP URL parse and FTP to illustrate content switching that relies on application Layer 7 technology. On top of all these it proposes the general suggestion of how to utilize load balance techniques in real scenario.

Keywords: load balance; cluster; layer 4 switch;layer 7 switch

1.   引言

Internet的快速增长使提供网络服务的服务器的负载急剧增加，面对的访问者数量快速增加，网络服务器需要具备提供大量并发访问服务的能力。而对于单独的服务器而言，CPU、I/O处理能力很快会成为瓶颈。简单的提高硬件性能并不能真正解决这个问题，因为单台服务器的性能总是有限的。必须采用多台服务器提供网络服务，并将网络请求分配给这些服务器分担，才能提供处理大量并发服务的能力。负载均衡（load balance）技术在这其中起到了关键的作用。

负载均衡的基本思路是多台服务器为对称方式，每台服务器都具备等价的地位，都可以单独对外提供服务而无须其他服务器的辅助。然后通过某种负载分担技术，将外部发送来的请求均匀分配到对称结构中的某一台服务器上，而接收到请求的服务器都独立回应客户机的请求。服务器内容的一致性一般靠共享存储，同步更新或者是数据库。多台服务器构成了一个所谓的集群(Cluster)。

现在业内流行的负载均衡器产品包括软件和硬件.软件以章文嵩博士的开源项目Linux Virtual Server(Lvs)为代表，而硬件产品的代表则有Nortel Networks公司(Alteon WebSystems)生产的 Alteon交换机，Cisco System公司生产的 Local Director交换机，F5 Networks公司生产的 F5交换机等。

2.   负载均衡技术的概况与分类

负载均衡是一种策略,它能让多台服务器或多条链路共同承担一些繁重的计算或I/ O 任

务,从而以较低成本消除网络瓶颈,提高网络的灵活性和可靠性。

负载均衡的实现方式有多种，包括基于DNS,基于客户端的，基于应用服务器和基于协议层的多种实现方式。

其中使用负载均衡器(load balancer)实现的基于协议层交换的负载均衡技术，包括第4层，第7层交换等。这种方式将负载均衡层与网络服务层分开，具有较高的可伸缩性和高可用性等特点，对于服务器和客户端而言透明，基本上无须做特别的修改。由于这样的特点，所以是最为流行也是广泛使用的技术。

2.1基于DNS的解决方法

最早的负载均衡技术是通过DNS服务中的随机名字解析来实现的，在DNS服务器中，可以为多个不同的地址配置同一个名字，而最终查询这个名字的客户机将在解析这个名字时得到其中的一个地址。因此，对于同一个名字，不同的客户机会得到不同的地址，他们也就访问不同地址上的Web服务器，从而达到负载均衡的目的。

DNS负载均衡的优点是简单、易行，并且服务器可以位于互联网的任意位置上，然而它也存在不少缺点，一个缺点是为了保证DNS数据及时更新，一般都要将DNS的刷新时间设置的较小，但太小就会造成太大的额外网络流量，并且更改了DNS数据之后也不能立即生效；第二点是DNS负载均衡无法得知服务器之间的差异，它不能做到为性能较好的服务器多分配请求，也不能了解到服务器的当前状态，甚至会出现客户请求集中在某一台服务器上的偶然情况。

DNS方法实现的是基于Round-Robin轮循的算法，它实现了一种粗粒度的负载均衡。

2.2基于客户端的解决方法

这种模式指的是在网络的客户端运行特定的程序，该程序通过某种手段得到所有服务器的信息，再根据某种选择策略，找到可以提供服务的最佳服务器，将本地的应用请求发向它。如果负载信息采集程序发现服务器失效，则找到其他可替代的服务器作为服务选择。整个过程对于应用程序来说是完全透明的，所有的工作都在运行时处理。因此这也是一种动态的负载均衡技术。

但这种技术存在通用性的问题。因为每一个客户端都要安装这个特殊的程序；并且，为了保证应用层的透明运行，需要针对每一个应用程序加以修改，通过动态链接库或者嵌入的方法，将客户端的访问请求能够先经过采集程序再发往服务器，以重定向的过程进行。对于每一个应用几乎要对代码进行重新开发，工作量比较大。

所以，这种技术仅在特殊的应用场合才使用到，比如在执行某些专有任务的时候，比较需要分布式的计算能力，对应用的开发没有太多要求。例如Oracle的客户端的配置文件Tnsname.ora中就可以对同一个数据库实例名写多个ip地址。当第一个地址访问不到时，客户端就会主动访问addresslist中的下一个ip地址。

2.3基于应用服务器的特定解决方法

如果将客户端的负载均衡层移植到某一个中间平台，形成三层结构，则客户端应用可以不需要做特殊的修改，透明的通过中间层应用服务器将请求均衡到相应的服务结点。比较常见的实现手段就是反向代理技术。所谓的反向代理与一般的代理相反，不是部署在靠近客户端的位置，而是靠近被访问的服务器的位置。

使用反向代理服务器，可以将请求均匀转发给多台服务器，或者直接将缓存的数据返回客户端，这样的加速模式在一定程度上可以提升静态网页的访问速度，从而达到负载均衡的目的。使用反向代理的好处是，可以将负载均衡和代理服务器的高速缓存技术结合在一起，提供有益的性能。然而它本身也存在一些问题，首先就是必须为每一种服务都专门开发一个反向代理服务器。

反向代理服务器针对每一次代理，就必须维护两个连接，一个对外的连接，一个对内的连接，因此对于特别高的连接请求，代理服务器的负载也就非常之大。反向代理能够执行针对应用协议而优化的负载均衡策略，每次仅访问最空闲的内部服务器来提供服务。但是随着并发连接数量的增加，代理服务器本身的负载也变得非常大，最后反向代理服务器本身会成为服务的瓶颈。例如，使用Apache的mod_rproxy模块来实现负载均衡功能时，提供的并发连接数量受Apache本身的并发连接数量的限制。

2.4基于使用负载均衡器的协议层的解决方法

与以上的方法相比，使用负载均衡器的协议层的解决方法实现了精细粒度的负载均衡。

在这种体系结构中，一组服务器通过高速的局域网或者地理分布的广域网相互连接，在它们的前端是负载均衡器。负载均衡器能无缝地将网络请求调度到真实服务器上，从而使得服务器集群的结构对客户是透明的，客户访问集群系统提供的网络服务就像访问一台高性能、高可用的服务器一样。客户程序不受服务器集群的影响不需作任何修改。系统的伸缩性通过在服务机群中透明地加入和删除一个节点来达到，通过检测节点或服务进程故障和正确地重置系统达到高可用性。整个集群具有单一的虚拟IP地址(VIP)。使集群中的服务器对客户端具有透明性。

均衡器通常称为OSI参考模型第4层的切换装置，因为在传输数据包时，它们除采用IP层的信息外，还采用了传输层(OSI参考模型第4层)的信息。

Schroeder等人对Web服务器集群技术进行了综述[2]，他们根据负载分配策略的细节将其分为以下三类：

l        L4/2――第4层交换，第2层分组转发

l        L4/3――第4层交换，第3层分组转发

l        L7－－第7层交换，也就是基于应用层内容的交换。

基本的服务器负载均衡，比如Web服务器的负载均衡通常采用第一和第二种方法就基本可以实现。而针对于某些特定的服务和特定的需求，则需要依靠第三种方法才能实现负载均衡。

从本质上讲，第4层的交换对网络协议中的源地址和目标地址进行了更改和替换，以便实现客户端访问一个绑定在负载均衡器上VIP到真实服务器ip（RIP）的转换，它根据特定的算法策略对所有的传输流进行修改。第4层的交换是基于状态的，负载均衡器对于每个会话都进行记录。 而源端口与目的端口的结合，以及第3层IP寻址，使TCP/UDP可以唯一地识别网络中地每一个会话。

而第7层的智能性能够进行进一步地控制，即对所有传输流和内容的控制。由于可以自由地完全打开传输流的应用／表示层，仔细分析其中的内容，因此可以根据应用的类型而非仅仅根据IP和端口号做出更智能的负载均衡决定。

3.   基于负载均衡器的协议层的技术

3.1. 第4层交换第2层分组转发

服务器负载均衡最简单的实现方法是使用第2层模型。此时，负载均衡器的所有接口在和客户端路由器与被访问的对象服务器处于相同的VLAN和IP子网中。它的主要优势是简单性。负载均衡器置于网络中时无须改变拓扑结构，也无须重新调整IP来实现负载均衡。但是缺点是每个服务器都要有一个在Internet上注册过的真实IP来提供对互联网客户端的服务。

假设客户端正在与位于10.10.10.0网络中的一个Web站点建立一个http连接，该网络通过VIP 10.10.10.100均衡器进行服务器负载均衡。由客户端向服务器的通信流如下：

（1）    客户端通过Dns查询或直接输入均衡器上的VIP，并发送一个TCP SYN数据包和VIP建立一个TCP会话。

（2）    TCP SYN数据包被发送到客户端路由器。客户端路由器将向10.10.10.0网络发送一个ARP广播以解析10.10.10.100的MAC地址。均衡器会以它的MAC地址来回应路由器的ARP广播，来代表VIP。

（3）    客户端路由器会向均衡器的MAC地址转发帧。此时，均衡器会作出一个负载均衡的算法判断，并转换MAC地址和目的IP地址为挑选出来的真实服务器的MAC和RIP，并且在每一层中改变校验和信息等。

而从服务器到客户机的通信流，则采用相反的逻辑。

（4）    服务器通过向默认网关10.10.10.1发送帧，来回应TCP SYN-ACK

（5）    由于帧必须通过均衡器并达到客户端路由器的默认网关，所以对MAC地址和源IP地址进行了逆向转换。

（6）    最后均衡器向客户端路由器的MAC地址转发帧，该路由器也向客户端发送返回数据包。

在此过程中，客户端和目标的真实服务器都没有察觉到负载均衡的发生，换句话说就是客户端看到的是自身和均衡器的VIP的持续连接，同时服务器看到的是没有涉及均衡器的客户端连接。

3.2. 第4层交换第3层分组转发

最常见的服务器负载均衡应该是第3层(路由)的服务器负载均衡。它与第2层的概念相似，但是区别在于，客户端路由器和对象服务器存在于不同的第2层VLAN和IP子网。均衡器对服务器和客户端间的帧进行路由而不是进行交换。均衡器同时也起到了路由的作用。

均衡器的位置可能成为客户端IP网络中的一员，这种情况下，客户端路由器无须关心服务器所在的子网，对真实服务器的访问可以通过均衡器上的VIP然后由NAT地址转换来实现，这样部署可以节约使用Internet注册地址。 第二种情况是VIP成为对象服务器所在网络中的一员，在这种情况下，服务器所在网络必须是可路由的公网，或者由其他一个NAT设备进行转换。最后一种情况，VIP是不与均衡器直接连接的子网的一员，客户端路由器必须配置一个静态路由来指向VIP所在的虚拟子网的均衡器的接口。

部署第3层的负载均衡有2个主要的优势

l        节省地址空间， 不必使用注册IP,使用符合RFC1918的地址空间即可。

l        简单， 均衡器同时作为一个路由器，更容易理解其网络拓扑。

3.3. 基于第7层内容交换技术

在一般情况下，使用第4层交换就可以达到基本的负载均衡，但是在有些情况下，对于某些应用，使用第7层所含的信息进行决策可以带来更大的益处。第7层的智能性能够进行进一步地控制，即对所有传输流和内容的控制。由于可以自由地