var msg="\nswitch流程控制语句 : \n\n";

//响应按钮的onclick事件处理程序
function Test()
{
  var army ;
  var year=window. prompt("请输入您的军龄(整数值,0表示未参军) :",25);
  
  switch(parseInt(year))
  {
    case 0:
    	
      army="平民";
      //alert(army);
      break;
    case 1:
      army="列兵";
      break;
    case 2:
      army="上等兵";
      break;
    case 3:
    case 4:
    case 5:
      army="一级士官";
      break;
    case 6:
    case 7:
    case 8:
      army="二级士官";
      break;
    default:
      if (year>8)
        army="中高级士官";
  }
  msg+="军龄 : "+year+"年\n";
  msg+="结论 : "+army+"\n";
  alert(msg);
}

 其中，year在使用时应转换为整型。

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

创建型模式

1、FACTORY —追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，虽然口味有所不同，但不管你带MM去麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。麦当劳和肯德基就是生产鸡翅的Factory

工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：如何创建及如何向客户端提供。

2、BUILDER  —MM最爱听的就是“我爱你”这句话了，见到不同地方的MM,要能够用她们的方言跟她说这句话哦，我有一个多种语言翻译机，上面每种语言都有一个按键，见到MM我只要按对应的键，它就能够用相应的语言说出“我爱你”这句话了，国外的MM也可以轻松搞掂，这就是我的“我爱你”builder。（这一定比美军在伊拉克用的翻译机好卖）

建造模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。建造模式可以强制实行一种分步骤进行的建造过程。

3、FACTORY METHOD —请MM去麦当劳吃汉堡，不同的MM有不同的口味，要每个都记住是一件烦人的事情，我一般采用Factory Method模式，带着MM到服务员那儿，说“要一个汉堡”，具体要什么样的汉堡呢，让MM直接跟服务员说就行了。

工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。

4、PROTOTYPE —跟MM用QQ聊天，一定要说些深情的话语了，我搜集了好多肉麻的情话，需要时只要copy出来放到QQ里面就行了，这就是我的情话prototype了。（100块钱一份，你要不要）

原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。原始模型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。缺点是每一个类都必须配备一个克隆方法。

5、SINGLETON —俺有6个漂亮的老婆，她们的老公都是我，我就是我们家里的老公Sigleton，她们只要说道“老公”，都是指的同一个人，那就是我(刚才做了个梦啦，哪有这么好的事)

单例模式：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例模式。单例模式只应在有真正的“单一实例”的需求时才可使用。

结构型模式

6、ADAPTER —在朋友聚会上碰到了一个美女Sarah，从香港来的，可我不会说粤语，她不会说普通话，只好求助于我的朋友kent了，他作为我和Sarah之间的Adapter，让我和Sarah可以相互交谈了(也不知道他会不会耍我)

适配器模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原因不匹配而无法一起工作的两个类能够一起工作。适配类可以根据参数返还一个合适的实例给客户端。

7、BRIDGE —早上碰到MM，要说早上好，晚上碰到MM，要说晚上好；碰到MM穿了件新衣服，要说你的衣服好漂亮哦，碰到MM新做的发型，要说你的头发好漂亮哦。不要问我“早上碰到MM新做了个发型怎么说”这种问题，自己用BRIDGE组合一下不就行了

桥梁模式：将抽象化与实现化脱耦，使得二者可以独立的变化，也就是说将他们之间的强关联变成弱关联，也就是指在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系，从而使两者可以独立的变化。

8、COMPOSITE —Mary今天过生日。“我过生日，你要送我一件礼物。”“嗯，好吧，去商店，你自己挑。”“这件T恤挺漂亮，买，这条裙子好看，买，这个包也不错，买。”“喂，买了三件了呀，我只答应送一件礼物的哦。”“什么呀，T恤加裙子加包包，正好配成一套呀，小姐，麻烦你包起来。”“……”，MM都会用Composite模式了，你会了没有？

合成模式：合成模式将对象组织到树结构中，可以用来描述整体与部分的关系。合成模式就是一个处理对象的树结构的模式。合成模式把部分与整体的关系用树结构表示出来。合成模式使得客户端把一个个单独的成分对象和由他们复合而成的合成对象同等看待。

9、DECORATOR —Mary过完轮到Sarly过生日，还是不要叫她自己挑了，不然这个月伙食费肯定玩完，拿出我去年在华山顶上照的照片，在背面写上“最好的的礼物，就是爱你的Fita”，再到街上礼品店买了个像框（卖礼品的MM也很漂亮哦），再找隔壁搞美术设计的Mike设计了一个漂亮的盒子装起来……，我们都是Decorator，最终都在修饰我这个人呀，怎么样，看懂了吗？

装饰模式：装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案，提供比继承更多的灵活性。动态给一个对象增加功能，这些功能可以再动态的撤消。增加由一些基本功能的排列组合而产生的非常大量的功能。

10、FAÇADE —我有一个专业的Nikon相机，我就喜欢自己手动调光圈、快门，这样照出来的照片才专业，但MM可不懂这些，教了半天也不会。幸好相机有Facade设计模式，把相机调整到自动档，只要对准目标按快门就行了，一切由相机自动调整，这样MM也可以用这个相机给我拍张照片了。

门面模式：外部与一个子系统的通信必须通过一个统一的门面对象进行。门面模式提供一个高层次的接口，使得子系统更易于使用。每一个子系统只有一个门面类，而且此门面类只有一个实例，也就是说它是一个单例模式。但整个系统可以有多个门面类。

11、FLYWEIGHT —每天跟MM发短信，手指都累死了，最近买了个新手机，可以把一些常用的句子存在手机里，要用的时候，直接拿出来，在前面加上MM的名字就可以发送了，再不用一个字一个字敲了。共享的句子就是Flyweight，MM的名字就是提取出来的外部特征，根据上下文情况使用。

享元模式：FLYWEIGHT在拳击比赛中指最轻量级。享元模式以共享的方式高效的支持大量的细粒度对象。享元模式能做到共享的关键是区分内蕴状态和外蕴状态。内蕴状态存储在享元内部，不会随环境的改变而有所不同。外蕴状态是随环境的改变而改变的。外蕴状态不能影响内蕴状态，它们是相互独立的。将可以共享的状态和不可以共享的状态从常规类中区分开来，将不可以共享的状态从类里剔除出去。客户端不可以直接创建被共享的对象，而应当使用一个工厂对象负责创建被共享的对象。享元模式大幅度的降低内存中对象的数量。

12、PROXY —跟MM在网上聊天，一开头总是“hi,你好”,“你从哪儿来呀？”“你多大了？”“身高多少呀？”这些话，真烦人，写个程序做为我的Proxy吧，凡是接收到这些话都设置好了自动的回答，接收到其他的话时再通知我回答，怎么样，酷吧。

代理模式：代理模式给某一个对象提供一个代理对象，并由代理对象控制对源对象的引用。代理就是一个人或一个机构代表另一个人或者一个机构采取行动。某些情况下，客户不想或者不能够直接引用一个对象，代理对象可以在客户和目标对象直接起到中介的作用。客户端分辨不出代理主题对象与真实主题对象。代理模式可以并不知道真正的被代理对象，而仅仅持有一个被代理对象的接口，这时候代理对象不能够创建被代理对象，被代理对象必须有系统的其他角色代为创建并传入。

行为模式

13、CHAIN OF RESPONSIBLEITY —晚上去上英语课，为了好开溜坐到了最后一排，哇，前面坐了好几个漂亮的MM哎，找张纸条，写上“Hi,可以做我的女朋友吗？如果不愿意请向前传”，纸条就一个接一个的传上去了，糟糕，传到第一排的MM把纸条传给老师了，听说是个老处女呀，快跑!

责任链模式：在责任链模式中，很多对象由每一个对象对其下家的引用而接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。客户并不知道链上的哪一个对象最终处理这个请求，系统可以在不影响客户端的情况下动态的重新组织链和分配责任。处理者有两个选择：承担责任或者把责任推给下家。一个请求可以最终不被任何接收端对象所接受。

14、COMMAND —俺有一个MM家里管得特别严，没法见面，只好借助于她弟弟在我们俩之间传送信息，她对我有什么指示，就写一张纸条让她弟弟带给我。这不，她弟弟又传送过来一个COMMAND，为了感谢他，我请他吃了碗杂酱面，哪知道他说：“我同时给我姐姐三个男朋友送COMMAND，就数你最小气，才请我吃面。”，

命令模式：命令模式把一个请求或者操作封装到一个对象中。命令模式把发出命令的责任和执行命令的责任分割开，委派给不同的对象。命令模式允许请求的一方和发送的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，更不必知道请求是怎么被接收，以及操作是否执行，何时被执行以及是怎么被执行的。系统支持命令的撤消。

15、INTERPRETER —俺有一个《泡MM真经》，上面有各种泡MM的攻略，比如说去吃西餐的步骤、去看电影的方法等等，跟MM约会时，只要做一个Interpreter，照着上面的脚本执行就可以了。

解释器模式：给定一个语言后，解释器模式可以定义出其文法的一种表示，并同时提供一个解释器。客户端可以使用这个解释器来解释这个语言中的句子。解释器模式将描述怎样在有了一个简单的文法后，使用模式设计解释这些语句。在解释器模式里面提到的语言是指任何解释器对象能够解释的任何组合。在解释器模式中需要定义一个代表文法的命令类的等级结构，也就是一系列的组合规则。每一个命令对象都有一个解释方法，代表对命令对象的解释。命令对象的等级结构中的对象的任何排列组合都是一个语言。

16、ITERATOR —我爱上了Mary，不顾一切的向她求婚。
   Mary：“想要我跟你结婚，得答应我的条件”
   我：“什么条件我都答应，你说吧”
   Mary：“我看上了那个一克拉的钻石”
   我：“我买，我买，还有吗？”
   Mary：“我看上了湖边的那栋别墅”
   我：“我买，我买，还有吗？”
   Mary：“你的小弟弟必须要有50cm长”
   我脑袋嗡的一声，坐在椅子上，一咬牙：“我剪，我剪，还有吗？”
   ……

迭代子模式：迭代子模式可以顺序访问一个聚集中的元素而不必暴露聚集的内部表象。多个对象聚在一起形成的总体称之为聚集，聚集对象是能够包容一组对象的容器对象。迭代子模式将迭代逻辑封装到一个独立的子对象中，从而与聚集本身隔开。迭代子模式简化了聚集的界面。每一个聚集对象都可以有一个或一个以上的迭代子对象，每一个迭代子的迭代状态可以是彼此独立的。迭代算法可以独立于聚集角色变化。

17、MEDIATOR —四个MM打麻将，相互之间谁应该给谁多少钱算不清楚了，幸亏当时我在旁边，按照各自的筹码数算钱，赚了钱的从我这里拿，赔了钱的也付给我，一切就OK啦，俺得到了四个MM的电话。

调停者模式：调停者模式包装了一系列对象相互作用的方式，使得这些对象不必相互明显作用。从而使他们可以松散偶合。当某些对象之间的作用发生改变时，不会立即影响其他的一些对象之间的作用。保证这些作用可以彼此独立的变化。调停者模式将多对多的相互作用转化为一对多的相互作用。调停者模式将对象的行为和协作抽象化，把对象在小尺度的行为上与其他对象的相互作用分开处理。

18、MEMENTO —同时跟几个MM聊天时，一定要记清楚刚才跟MM说了些什么话，不然MM发现了会不高兴的哦，幸亏我有个备忘录，刚才与哪个MM说了什么话我都拷贝一份放到备忘录里面保存，这样可以随时察看以前的记录啦。

备忘录模式：备忘录对象是一个用来存储另外一个对象内部状态的快照的对象。备忘录模式的用意是在不破坏封装的条件下，将一个对象的状态捉住，并外部化，存储起来，从而可以在将来合适的时候把这个对象还原到存储起来的状态。

19、OBSERVER   —想知道咱们公司最新MM情报吗？加入公司的MM情报邮件组就行了，tom负责搜集情报，他发现的新情报不用一个一个通知我们，直接发布给邮件组，我们作为订阅者（观察者）就可以及时收到情报啦

观察者模式：观察者模式定义了一种一队多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使他们能够自动更新自己。

20、STATE —跟MM交往时，一定要注意她的状态哦，在不同的状态时她的行为会有不同，比如你约她今天晚上去看电影，对你没兴趣的MM就会说“有事情啦”，对你不讨厌但还没喜欢上的MM就会说“好啊，不过可以带上我同事么？”，已经喜欢上你的MM就会说“几点钟？看完电影再去泡吧怎么样？”，当然你看电影过程中表现良好的话，也可以把MM的状态从不讨厌不喜欢变成喜欢哦。

状态模式：状态模式允许一个对象在其内部状态改变的时候改变行为。这个对象看上去象是改变了它的类一样。状态模式把所研究的对象的行为包装在不同的状态对象里，每一个状态对象都属于一个抽象状态类的一个子类。状态模式的意图是让一个对象在其内部状态改变的时候，其行为也随之改变。状态模式需要对每一个系统可能取得的状态创立一个状态类的子类。当系统的状态变化时，系统便改变所选的子类。

21、STRATEGY —跟不同类型的MM约会，要用不同的策略，有的请电影比较好，有的则去吃小吃效果不错，有的去海边浪漫最合适，单目的都是为了得到MM的芳心，我的追MM锦囊中有好多Strategy哦。

策略模式：策略模式针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。策略模式把行为和环境分开。环境类负责维持和查询行为类，各种算法在具体的策略类中提供。由于算法和环境独立开来，算法的增减，修改都不会影响到环境和客户端。

22、TEMPLATE METHOD ——看过《如何说服女生上床》这部经典文章吗？女生从认识到上床的不变的步骤分为巧遇、打破僵局、展开追求、接吻、前戏、动手、爱抚、进去八大步骤(Template method)，但每个步骤针对不同的情况，都有不一样的做法，这就要看你随机应变啦(具体实现)；

模板方法模式：模板方法模式准备一个抽象类，将部分逻辑以具体方法以及具体构造子的形式实现，然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法，从而对剩余的逻辑有不同的实现。先制定一个顶级逻辑框架，而将逻辑的细节留给具体的子类去实现。

23、VISITOR —情人节到了，要给每个MM送一束鲜花和一张卡片，可是每个MM送的花都要针对她个人的特点，每张卡片也要根据个人的特点来挑，我一个人哪搞得清楚，还是找花店老板和礼品店老板做一下Visitor，让花店老板根据MM的特点选一束花，让礼品店老板也根据每个人特点选一张卡，这样就轻松多了；

访问者模式：访问者模式的目的是封装一些施加于某种数据结构元素之上的操作。一旦这些操作需要修改的话，接受这个操作的数据结构可以保持不变。访问者模式适用于数据结构相对未定的系统，它把数据结构和作用于结构上的操作之间的耦合解脱开，使得操作集合可以相对自由的演化。访问者模式使得增加新的操作变的很容易，就是增加一个新的访问者类。访问者模式将有关的行为集中到一个访问者对象中，而不是分散到一个个的节点类中。当使用访问者模式时，要将尽可能多的对象浏览逻辑放在访问者类中，而不是放到它的子类中。访问者模式可以跨过几个类的等级结构访问属于不同的等级结构的成员类。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

<iframe src="http://www.baidu.com" width="100%" height="100%"  onload="this.style.height=this.document.body.scrollHeight;this.style.width=this.document.body.scrollWidth" ></iframe>

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

在controller里设置一个before_filter

例：

before_filter :set_charset
def set_charset
  @headers["Content-Type"] = "text/html; charset=UTF-8"
end

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

<!DOCTYPE
html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"
/>
<title>¶�pdownµ¯³�¥--A CROSS BROWSER DROP DOWN CASCADING
VALIDATING MENU</title>
<style type="text/css">
/* common styling */
/* set up the overall width of the menu div, the font and the margins
*/
.menu {
font-family: arial, sans-serif; width:750px; margin:0; margin:0px 0;
}
/* remove the bullets and set the margin and padding to zero for the
unordered list */
.menu ul {
padding:0; margin:0;
list-style-type: none;
}
/* float the list so that the items are in a line and their position
relative so that the drop down list will appear in the right place
underneath each list item */
.menu ul li {
float:left; position:relative;
}
/* style the links to be 104px wide by 30px high with a top and right
border 1px solid white. Set the background color and the font size. */
.menu ul li a, .menu ul li a:visited {
display:block; text-align:center; text-decoration:none; width:104px;
height:30px; color:#000; border:1px solid #fff;
border-width:1px 1px 0 0;
background:#c9c9a7; line-height:30px; font-size:11px;
}
/* make the dropdown ul invisible */
.menu ul li ul {
display: none;
}
/* specific to non IE browsers */
/* set the background and foreground color of the main menu li on hover
*/
.menu ul li:hover a {
color:#fff; background:#b3ab79;
}
/* make the sub menu ul visible and position it beneath the main menu
list item */
.menu ul li:hover ul {
display:block; position:absolute; top:31px; left:0; width:105px;
}
/* style the background and foreground color of the submenu links */
.menu ul li:hover ul li a {
display:block; background:#faeec7; color:#000;
}
/* style the background and forground colors of the links on hover */
.menu ul li:hover ul li a:hover {
background:#dfc184; color:#000;
}
.testing{width:800px; height:30px;line-height:30px;text-align:left;background-color:Green;}
.redBorder{border:1px solid Red;}
</style>
<!--[if lte IE 6]>
<style type="text/css">
/* styling specific to Internet Explorer IE5.5 and IE6. Yet to see if
IE7 handles li:hover */
/* Get rid of any default table style */
table {
border-collapse:collapse;
margin:0; padding:0;
}
/* ignore the link used by 'other browsers' */
.menu ul li a.hide, .menu ul li a:visited.hide {
display:none;
}
/* set the background and foreground color of the main menu link on
hover */
.menu ul li a:hover {
color:#fff; background:#b3ab79;
}
/* make the sub menu ul visible and position it beneath the main menu
list item */
.menu ul li a:hover ul {
display:block; position:absolute; top:32px; left:0; width:105px;
}
/* style the background and foreground color of the submenu links */
.menu ul li a:hover ul li a {
background:#faeec7; color:#000;
}
/* style the background and forground colors of the links on hover */
.menu ul li a:hover ul li a:hover {
background:#dfc184; color:#000;
}
</style>
<![endif]-->
</head>
<body>
	<div class="testing">hello-----------testing</div>
<div class="menu redBorder">
<ul>
<li><a class="hide"
href="../menu/index.html">DEMOS</a>
<!--[if lte IE 6]>
<a href="../menu/index.html">DEMOS
<table><tr><td>
<![endif]--> <ul> <li><a
href="../menu/zero_dollars.html" title="The zero dollar ads
page">zero dollars</a></li> <li><a
href="../menu/embed.html" title="Wrapping text around
images">wrapping text</a></li> <li><a
href="../menu/form.html" title="Styling forms">styled
form</a></li> <li><a href="../menu/nodots.html"
title="Removing active/focus borders">active
focus</a></li> <li><a
href="../menu/shadow_boxing.html" title="Multi-position drop
shadow">shadow boxing</a></li> <li><a
href="../menu/old_master.html" title="Image Map for detailed
information">image map</a></li> <li><a
href="../menu/bodies.html" title="fun with background images">fun
backgrounds</a></li> <li><a
href="../menu/fade_scroll.html" title="fade-out scrolling">fade
scrolling</a></li> <li><a
href="../menu/em_images.html" title="em size images compared">em
sized images</a></li> </ul>
<!--[if lte IE 6]>
</td></tr></table>
</a>
<![endif]-->
</li>
<li><a class="hide" href="index.html">MENUS</a>

<!--[if lte IE 6]>
<a href="index.html">MENUS
<table><tr><td>
<![endif]-->

    <ul>
    <li><a href="spies.html" title="a coded list of spies">spies menu</a></li>
    <li><a href="vertical.html" title="a horizontal vertical menu">vertical menu</a></li>
    <li><a href="expand.html" title="an enlarging unordered list">enlarging list</a></li>
    <li><a href="enlarge.html" title="an unordered list with link images">link images</a></li>
    <li><a href="cross.html" title="non-rectangular links">non-rectangular</a></li>
    <li><a href="jigsaw.html" title="jigsaw links">jigsaw links</a></li>
    <li><a href="circles.html" title="circular links">circular links</a></li>
    </ul>

<!--[if lte IE 6]>
</td></tr></table>
</a>
<![endif]-->

</li>

<li><a class="hide" href="../layouts/index.html">LAYOUTS</a>

<!--[if lte IE 6]>
<a href="../layouts/index.html">LAYOUTS
<table><tr><td>
<![endif]-->

    <ul>
    <li><a href="../layouts/bodyfix.html" title="Cross browser fixed layout">Fixed 1</a></li>
    <li><a href="../layouts/body2.html" title="Cross browser fixed layout">Fixed 2</a></li>
    <li><a href="../layouts/body4.html" title="Cross browser fixed layout">Fixed 3</a></li>
    <li><a href="../layouts/body5.html" title="Cross browser fixed layout">Fixed 4</a></li>
    <li><a href="../layouts/minimum.html" title="A simple minimum width layout">minimum width</a></li>
    </ul>

<!--[if lte IE 6]>
</td></tr></table>
</a>
<![endif]-->

</li>

<li><a class="hide" href="../boxes/index.html">BOXES</a>

<!--[if lte IE 6]>
<a href="../boxes/index.html">BOXES
<table><tr><td>
<![endif]-->

    <ul>
    <li><a href="spies.html" title="a coded list of spies">spies menu</a></li>
    <li><a href="vertical.html" title="a horizontal vertical menu">vertical menu</a></li>
    <li><a href="expand.html" title="an enlarging unordered list">enlarging list</a></li>
    <li><a href="enlarge.html" title="an unordered list with link images">link images</a></li>
    <li><a href="cross.html" title="non-rectangular links">non-rectangular</a></li>
    <li><a href="jigsaw.html" title="jigsaw links">jigsaw links</a></li>
    <li><a href="circles.html" title="circular links">circular links</a></li>
    </ul>

<!--[if lte IE 6]>
</td></tr></table>
</a>
<![endif]-->

</li>

<li><a class="hide" href="../mozilla/index.html">MOZILLA</a>

<!--[if lte IE 6]>
<a href="../mozilla/index.html">MOZILLA
<table><tr><td>
<![endif]-->

    <ul>
    <li><a href="../mozilla/dropdown.html" title="A drop down menu">drop down menu</a></li>
    <li><a href="../mozilla/cascade.html" title="A cascading menu">cascading menu</a></li>
    <li><a href="../mozilla/content.html" title="Using content:">content:</a></li>
    <li><a href="../mozilla/moxbox.html" title=":hover applied to a div">mozzie box</a></li>
    <li><a href="../mozilla/rainbow.html" title="I can build a rainbow">rainbow box</a></li>
    <li><a href="../mozilla/snooker.html" title="Snooker cue">snooker cue</a></li>
    <li><a href="../mozilla/target.html" title="Target Practise">target practise</a></li>
    <li><a href="../mozilla/splittext.html" title="Two tone headings">two tone headings</a></li>
    <li><a href="../mozilla/shadow_text.html" title="Shadow text">shadow text</a></li>
    </ul>

<!--[if lte IE 6]>
</td></tr></table>
</a>
<![endif]-->

</li>

<li><a class="hide" href="../ie/index.html">EXPLORER</a>

<!--[if lte IE 6]>
<a href="../ie/index.html">EXPLORER
<table><tr><td>
<![endif]-->

    <ul>
    <li><a href="../ie/exampleone.html" title="Example one">example one</a></li>
    <li><a href="../ie/weft.html" title="Weft fonts">weft fonts</a></li>
    <li><a href="../ie/exampletwo.html" title="Vertical align">vertical align</a></li>
    </ul>

<!--[if lte IE 6]>
</td></tr></table>
</a>
<![endif]-->

</li>

<li><a class="hide" href="../opacity/index.html">OPACITY</a>

<!--[if lte IE 6]>
<a href="../opacity/index.html">OPACITY
<table><tr><td>
<![endif]-->

    <ul>
    <li><a href="../opacity/colours.html" title="colour wheel">opaque colours</a></li>
    <li><a href="../opacity/picturemenu.html" title="a menu using opacity">opaque menu</a></li>
    <li><a href="../opacity/png.html" title="partial opacity">partial opacity</a></li>
    <li><a href="../opacity/png2.html" title="partial opacity II">partial opacity II</a></li>
    </ul>

<!--[if lte IE 6]>
</td></tr></table>
</a>
<![endif]-->

</li>
</ul>

<!-- clear the floats if required -->
<div class="clear"> </div>

</div>
</body>
</html>
<div class="testing">hello-----------testing</div>

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

测试结果

HAproxy和Lighttpd的测试需要调整很多参数，我们先看看无需调整参数的几种方案的测试结果，我同样除了原始数据的折线图，还会给出B样条的图以更清晰地看到结果：

从图上我们看到Nginx+Mongrel的方式性能很稳定，但在并发量小于150的情况下与其他方案相比还是差很多的。
Nginx+Thin/Evented Mongrel两种方式的性能则相差不大，毕竟都是使用的EventMachine。
Swiftiply的两种方式都体现出了很高的性能，尤其是Swiftiply+Swiftiplied Mongrel令人影响深刻，即使在500的并发量左右，性能依然保持稳定。
Apache+Passenger模式在低并发（<=300）的情况下效率很高，但随着并发量上升，Apache的两种工作模式本身的效率下降得就很快，Prefork模式在大于450的情况下降到了0（我认为是出现了TCP错误导致AB测试中断）。
这个测试中，除了Nginx，其他的搭配方式Swiftiply和Passenger，应该每次都只给后端一个请求，同时也应该是建立的持久链接。
HAproxy/Mongrel的测试结果

通过对HAproxy的maxconn参数的调整，得到了如上图的测试结果，我们不难发现在maxconn=1的情况下是效率最高的，这印证了前面对后端缺点的分析。因为在限制了每次只有一个链接之后，Mongrel的进程减少了锁和上下文切换的开销，所以得到了很稳定的性能，另外我们还可以注意到，随着maxconn越来越大，最后达到50的时候，这时候Mongrel进程中对于锁和上下文切换的开销也趋于平稳，情况变成了和Nginx/Mongrel的情况一样。
通过对比，我们可以发现，利用HAproxy限制到Mongrel的链接数为1，可以比Nginx+Mongrel的方式性能提高23%～28%，不过相比Passenger/Swiftiply方式而言，还是差一点点，但性能依然十分稳定。
这也是为什么ThoughtWorks的Rubyworks采用了HAproxy的缘故，我觉得在Rubyworks推出的当时是非常正确的选择，因为当时没有其他选择。

HAproxy/Thin的测试结果

由于Thin没有锁和上下文切换的开销，因此限制maxconn在测试结果上不如对Mongrel的效果那么明显。但基本上也可以看出来，将链接到后端的连接数限制在较小的范围内会对性能和稳定性有更好的帮助。
Lighttpd/Mongrel的测试结果

Lighttpd+Mongrel的图像与HAproxy+Mongrel的非常不同，尤其是在限制到后端的链接效果上。我在测试结果中发现了大量的504Gatewaytimeout错误返回，从而导致了响应速度的降低。随着链接限制参数的变大，504错误越来越少。我们可以发现在并发量小于100的时候，其效果还是和HAproxy类似的。当链接限制大到一定程度，其效果和Nginx+Mongrel的方式也是一样的。
Lighttpd/Thin的测试结果

Lighttpd搭配Thin的情况同样出现了Mongrel一样的情况，在max-pool-size参数为1的时候出现了大量的504错误返回，并随着这个参数的增加错误数减少。
Lighttpd+Thin的方式在不限制连接数的情况下性能要大大优于Nginx+Thin和HAproxy+Thin的方式。
Lighttpd/FastCGI的测试结果
通过Socket方式

通过TCP方式

我们可以发现Lighttpd的FastCGI方式走TCP或Socket在性能方面没有太大差别，但限制链接数容易造成Lighttpd直接给出错误返回，随着连接数限制的放宽，错误数也减少，响应速度也变得稳定。

根据前面对后端的测试，无论何种后端都应该在低链接的情况下有更好的表现，Lighttpd为何在限制了连接数之后反而有更过504错误呢，我认为是Lighttpd未实现像Apache和HAproxy的双重链接池的功能，同时Lighttpd的默认的超时时间又只有10秒钟。在Apache和HAproxy的情况中，当链接未进入某个后端服务器的等待队列时，会等待Timeout时间，而进入了后端等待队列之后会重新等待TTL的时间，这样就避免了快达到Timeout的时候进入等待队列没多久就被放弃的情况。当然Apache和HAproxy的Timeout和TTL参数也需要根据系统的性能和要求小心调整。而对于Lighttpd则可以考虑适当增大Timeout时间。

分析和小结

我先来将本案中的各种部署方式的性能排个名次，以下是后各种方案在并发量>=10的情况下的平均值（去掉出现0值的情况）：

 

前端	后端	平均每秒响应数	最大链接限制
Lighttpd	FastCGI/TCP	215.33	64
Lighttpd	FastCGI/Socket	214.65	64
Lighttpd	Thin	196.16	64
Swiftiply	Swiftiplied Mongrel	191.33	N/A
HAproxy	Thin	188.73	10
Swiftiply	Thin(Swiftiplied)	178.96	N/A
Apache2.2/Prefork	Passenger	173.02	N/A
HAproxy	Mongrel	170.4	1
Apache2.2/Worker	Passenger	163.9	N/A
Lighttpd	Mongrel	149.85	64
Nginx	Evented Mongrel	149.78	N/A
Nginx	Thin	143.88	N/A
Nginx	Mongrel	138.86	N/A

在这个表中，Lighttpd的三种方案占据了前三位，Lighttpd+FastCGI是性能最高的部署方式。这种方式比另一种流行方案Nginx+Mongrel的方式性能提升了高达50%！
FastCGI的好处在此体现出来：

• 二进制协议，无需HTTP的解析
• 与前端可以建立持久链接
• 没有锁和上下文切换的开销

另外Lighttpd相对于Nginx的优势在于请求和响应的接收缓冲区很大，省去多次接收和发送的开销。
Lighttpd+Thin的方式的性能列第三位，这点似乎出乎意料之外，但实际上是因为Lighttpd 1.5支持对HTTP后端建立HTTP KeepAlive链接。在对后端单独的测试中，小并发下的Thin的KeepAlive测试性能并不比FastCGI差，同时Thin实现了非阻塞IO，而FastCGI则是阻塞式的。相反，HAproxy和Nginx则都不支持HTTP KeepAlive。
而Swiftiply的方式也显示出了强劲的性能，应该是得益于它的“让后端主动连接到Swiftiply”的这种特殊的结构。
当前备受关注的Passenger的部署方式在本案中并没有显示出特别的性能上的优势，不过如果将并发链接数放在300以内，则Apache2.2/Prefork + Passenger的部署方式的平均每秒响应数上升为204.03，这样看来，倘若为Apache进行一些优化配置，依然不失为一种高效的部署方案。而同时Passenger又是最容易配置的一种方案，能达到这种效果已经非常令人满意。
HAproxy + Mongrel并限制链接数为1，则是一种稳定、保守的部署方式，虽然在这里性能不出众，但是稳定性非常好。
最后，与Nginx相关的三种方案都排在了该榜的末尾，由于Nginx的反向代理负载均衡缺少一些高级的特性以及Rails本身的特性而导致其不适合单独应用在Rails程序的部署上：

• 缺少到后台服务器端的链接数限制的能力，这导致了Mongrel在接受大量请求时将时间消耗在上下文切换和锁的争用上。
• 缺乏建立到后台服务器端的持久链接的能力，这导致了在链接的打开、建立、关闭上花费了额外的开销。

延伸

Windows操作系统
由于*nix操作系统中，可以替代Apache的选择很多，而Windows下基本上只能使用Apache2.2+Mongrel的方式了，想使用Thin的朋友要记得单独安装EventMachine 0.8.1 ，目前最新的Windows安装包。
我给出一个比较合理的Apache2.2的配置，最简化的配置文件如下：

ThreadsPerChild 1024
MaxRequestsPerChild 0

ServerRoot "C:/Apache2"
Listen 80
KeepAlive off
KeepAliveTimeout 15
Timeout 30
MaxKeepAliveRequests 1024

LoadModule log_config_module modules/mod_log_config.so
LoadModule proxy_module modules/mod_proxy.so
LoadModule proxy_balancer_module modules/mod_proxy_balancer.so
LoadModule proxy_http_module modules/mod_proxy_http.so
LoadModule rewrite_module modules/mod_rewrite.so
LoadModule status_module modules/mod_status.so

ServerAdmin admin@shiningray.cn
ServerName shiningray.cn
DocumentRoot "D:/wwwroot/rails/public"
ErrorLog logs/error.log
LogLevel warn

<IfModule log_config_module>
    LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\"" combined
    LogFormat "%h %l %u %t \"%r\" %>s %b" common

    <IfModule logio_module>
      LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\" %I %O" combinedio
    </IfModule>

    CustomLog logs/access.log common
</IfModule>

<Proxy balancer://mongrels>
    BalancerMember http://127.0.0.1:30000 max=10 smax=1
    BalancerMember http://127.0.0.1:30001 max=10 smax=1
    #在这里放更多的后端服务器
</Proxy>

ProxyRequests off
RewriteEngine On   
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_FILENAME} !-f
RewriteRule ^/(.*)$ balancer://mongrels%{REQUEST_URI} [QSA,P,L]

其中，smax=1表示限制到后端的最大链接数为1，max=10表示等待队列为10。如果后端是Mongrel，这样就可以解决Mongrel接受大量请求对锁和上下文切换的消耗。
而如果后端采用了Thin，根据前面的测试结果，应该打开KeepAlive功能，即在每个BalancerMember后面加上keepalive=on，并且适当提升max和smax的值，以充分利用Thin的特性。关于这些参数可以参考ProxyPass指令的解释。
在本文中就不对该平台下的部署方式进行性能测试了，这种方案通常是在对遗留项目的迁移中才会出现，建议Rails应用还是最终应该部署在*nix的平台上以达到最好的性能。

其他有意思的部署方式
当然，除了前面的几种方案之外，我们可以还可以根据实际情况采用不同的组合来实现功能，下面我给出几个复杂一些的方案，希望能抛砖引玉。
一、虽然Nginx不能限制到对后端的链接，而HAproxy又不支持静态文件，那么二者结合会怎样呢？我在公司的一台CentOS 3的服务器上便使用的是Nginx+HAproxy+Mongrel的方式。由于这个部署方式是对HAproxy+Mongrel在外面套一层，性能基本基本接近没有太大差别，便不放测试测试数据了。
二、之前提到了Nginx不支持对FastCGI的后端进行分发，似乎有些遗憾，但我们也提到HAproxy也可以做TCP转发的负载均衡器，利用Nginx+HAproxy来对FastCGI的后端做请求分发效果会如何呢？
于是我做了个测试：
HAproxy的配置改为：

# this config needs haproxy-1.1.28 or haproxy-1.2.1

global
    log 127.0.0.1    local0
    log 127.0.0.1    local1 notice
    #log loghost    local0 info
    maxconn 2000
    #chroot /usr/share/haproxy
    #uid 99
    #gid 99
    #daemon
    #debug
    #quiet

defaults
    log    global
    mode    http
    option    httplog
    option    dontlognull
    retries    3
    redispatch
    maxconn    2000
    contimeout    5000
    clitimeout    50000
    srvtimeout    50000

listen test 0.0.0.0:9000
    mode tcp
    balance roundrobin
    server mongrel_30000 127.0.0.1:30000 maxconn 8
    server mongrel_30001 127.0.0.1:30001 maxconn 8
    server mongrel_30002 127.0.0.1:30002 maxconn 8
    server mongrel_30003 127.0.0.1:30003 maxconn 8
    server mongrel_30004 127.0.0.1:30004 maxconn 8
    server mongrel_30005 127.0.0.1:30005 maxconn 8
    server mongrel_30006 127.0.0.1:30006 maxconn 8
    server mongrel_30007 127.0.0.1:30007 maxconn 8
    server mongrel_30008 127.0.0.1:30008 maxconn 8
    server mongrel_30009 127.0.0.1:30009 maxconn 8

Nginx的配置改为：

worker_processes 1;

events {
    worker_connections 1024;
    use epoll;
}

http {
    include       mime.types;
    default_type application/octet-stream;

    sendfile        on;
    #tcp_nopush     on;

    #keepalive_timeout 0;
    keepalive_timeout 65;

    server {
        listen       8080;
        server_name localhost;

        root /home/shiningray/NetBeansProjects/botadmin/public;
        location / {
            include fastcgi_params;
            if (-f $request_filename/index.html) {
                rewrite (.*) $1/index.html break;
            }
            if (-f $request_filename.html) {
                rewrite (.*) $1.html break;
            }
            if (!-f $request_filename) {

                fastcgi_pass 127.0.0.1:9000;
                break;
            }
        }
        error_page   500 502 503 504 /50x.html;
        location = /50x.html {
            root   html;
        }
    }
}

据我测试，此部署方案的性能也可以与Lighttpd的几种一较高下，但毕竟因为多了一层，还是略占下风。
这两种方案部署上更为繁琐，小型应用上其实只需要考虑前面的两层方案便可，在此不做详细的评测了。

其它问题

除了对部属方案的性能考虑之外，我们还需要考虑一些别的问题。比如，Mongrel后端的启动是通过mongrel_cluster启动的，我们只要安装这个gem便可，如果要添加为自启动脚本可以利用mongrel_cluster自带的init脚本。但是这些脚本不能实现当mongrel进程崩溃、退出后的重新启动，同时，如果配置不恰当，当mongrel进程被强制杀死或系统宕机之后，mongrel遗留的pid文件会导致无法启动mongrel进程，必须先删除这些文件（Mongrel_cluster提供了--clean选项来事先清除无用pid）。FastCGI进程也有同样的问题。
有一个非常好的进程监控程序称之为Monit。Rubyworks也搭配了Monit来监控Mongrel的进程，而不使用Mongrel_cluster。并且monit可以限制mongrel的进程的内存用量，防止出现内存溢出的问题等。同时monit也可以监控其他的进程如我们的前端。

总结

Rails的部署方式的核心问题就在于解决一、Rails本身是非线程安全，二、Ruby的线程性能差这两个问题上。本文列举了十余种常见的Rails部署方案，其中基于Lighttpd 1.5的几种解决方案都从原理上很好地解决了Rails部署的两大问题，而且有着不俗的性能。由于本案中的测试仅建立在我为公司的服务器端所做测试的基础上，并且设计、执行得不够严谨，仅仅具有一定的参考意义。另外限于我的能力和精力问题，通过JRuby借助JavaEE平台的部署方案未能进行评测，我相信也是很有潜力的方案。

不同的部署方式都有各自的优势，大家需要根据各自所开发的应用的特点和服务器特点来选择恰当的部署方式，例如跨平台性、易用性。
这些方案虽然是针对Ruby on Rails应用的，但是其中的原理是通用的，也希望能对大家在其他应用的部署和架构上有些启发。

http://docs.google.com/View?docid=ddcvzh74_28f9xppqfh

http://hi.baidu.com/gsxu/blog/item/e3aa518d11aa1b14b21bbae9.html

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

@guard.synchronize {
              @active_request_path = request.params[Mongrel::Const::PATH_INFO] 
              Dispatcher.dispatch(cgi, 
                ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS, 
                response.body)
              @active_request_path = nil
            }

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

作者：ShiningRay 前言 2006初，我接到了公司分配的一个遗留项目，让我负责一个基于C/S的系统的服务器端。其实是系统是基于HTTP协议的，因为负责客户端的同事对于服务器端编程不甚了解，虽然使用PHP对熟悉C＋＋的他来说是驾轻就熟，但是在进一步实现更多的功能和更高的性能上就捉襟见肘了。项目是在非常突然的情况下交给我的，因为该同事在客户端上有更多的事情要做。我在分析了他的数据库结构和PHP源代码之后，决定按照与客户端的通讯协议重写他的服务器端。为了能应付老板苛刻的时间限制，我打算使用正在学习的Ruby on Rails。后来，项目在功能上非常顺利地交付了。 两年过去了，随着客户端数量的不断增加、客户端功能的增加、与服务器端交互数据的增加、老板对功能的要求不断增加，我在这个项目上走了不少弯路，尤其是在部署——或者说是架构——方面。 我遇到的最大的问题就在于并发链接数上。服务器与客户端的每次交互的数据量并不大，但内容无法缓存。起初用的是Nginx/Apache+Mongrel的部署方式，但当遇到大量并发请求时，常常会遇到Mongrel进程死掉的情况。而客户端的用户在无法登录客户端的时候，经常会反复尝试，加重了服务器的负担、导致最后所有的Mongrel进程都挂掉。 最后，经过不懈努力，在现有的3台低端服务器上，可以满足每天500万次的请求。在这里，我将我的一些心得和研究成果总结出来，与大家分享。 简介 Ruby on Rails的部署方案基本上都是由两层结构组成，前端做请求的分发，后端以多个Ruby进程接受并处理请求，主要的差别便是其中的通讯协议，比如使用FastCGI 或者是HTTP。这里讨论的局限于一台服务器，所以我不称之为架构方案，而仅仅是部署配置方案。 前端的选择 前端也有很多种不同的选择，我们来看一下开源领域主流的选择： Apache Apache功能十分强大，稳定性也十分好，是全球市场占有率最高的Web服务器。与它搭配的Rails部署方案也有很多，如： Apache+mod_ruby：类似于mod_php、mod_python，将Ruby解释器作为一个模块加载到Apache中。（mod_ruby以及停止更新，所以并不流行） Apache+mod_fastcgi或Apache+mod_fcgid，通过FastCGI协议与Rails进程通讯。（mod_fastcgi由于设计有缺陷因此仅推荐使用mod_fcgid） Apache2.2 + mod_proxy_balancer：使用反向代理负载均衡器，通过HTTP与后端的Ruby Web服务器通讯，如Mongrel/Thin/Ebb等。 Apache2 + Passenger (mod_rails) ：新兴的模块方式，部署方式十分简单，大致的方式和FastCGI差不多，只不过与后台进程间的通讯协议使用了它自己的协议。 Apache的一大问题就是Apache的性能和一些轻量级新秀Web服务器相比差很多，原因在于Apache到目前为止仅有prefork（进程）模式和worker（线程）模式的MPM是稳定的，这两种工作方式每服务一个链接，就需要创建一个进程或线程，而新兴的轻量级Web服务器，则都很好地利用内核的事件机制提高性能，极大地减少了线程或进程数量，而Apache的event（事件）模式的MPM依然在开发中。例如，Apache的请求处理速度、并发处理能力都比Lighttpd慢3-5倍，内存消耗和CPU消耗也高出很多。另一个问题是，mod_proxy_balancer虽然功能强大，但分发性能不高，比HAproxy或Nginx差很多。 基于这些问题，所以Apache+FastCGI/mod_proxy_balancer的部署方案并不流行，然而新兴的Passenger由于部署方式出奇简单，使得Apache可能会重新在Rails部署上再次占据一席之地。 Lighttpd 轻量级高性能Web服务器，服务静态文件的性能非常高。目前的稳定版本Lighttpd1.4中的反向代理模块有所缺陷，此模块会在1.5中全部重写并提供更好的负载均衡算法，可以对基于FastCGI、HTTP、AJP、SCGI的后端进行请求分发。Lighttpd+FastCGI是目前非常流行的一种部署方式，国内著名的JavaEye便采用的这种方式，JavaEye 负责人之一Robbin对Lighttpd+FastCGI的方式推崇备至。 Nginx Nginx也是一个轻量级高性能的Web服务器/反向代理负载均衡器。Nginx也支持FastCGI，但不像Lighttpd 1.5支持对FastCGI后端的负载均衡调度。Nginx+Mongrel的方式受到很多人推荐。 HAproxy HAproxy是一个纯粹的反向代理均衡器，非常小巧，基于事件机制。它不仅可以做HTTP反向代理，还可以作TCP的转发，所以同样可以对FastCGI做负载均衡。在做HTTP反向代的同时可以对请求作一些修改控制。在ThoughtWorks推出的Rubyworks这个Rails应用套件中用到了它，原因是它能很方便地限制到后端服务器的链接数量。但HAproxy不是Web服务器，它不能处理静态文件。 Swiftiply Swiftiply是一个负载均衡反向代理，但它与后端服务器的通讯方式很特殊——它开放一个端口让后端服务器主动链接到Swiftiply，这样可以与后端服务器建立一个持久链接，而且无须重启就可以非常容易地增加新的后端。Swiftiply使用了Ruby的EventMachine 实现了实践驱动机制。支持它的协议的后端有Swiftiplied Mongrel和Thin。 后端的选择 后端Rails的运行方式可以通过FastCGI或者是Ruby应用服务器的方式，CGI和mod_ruby已经不推荐。可以选的Ruby服务器有有： WEBrick WEBrick是Ruby标准库中自带的默认HTTP服务器，完全使用Ruby写成，性能较差。利用了Ruby的线程来服务并发的链接。有人写了利用事件机制来提高性能的补丁，由于应用少，不在讨论范围。 Mongrel 目前最为成熟Ruby应用服务器。使用了C++写的HTTP头解析器，所以具有较好的性能，它同样利用了Ruby的线程机制来服务并发的链接。Mongrel的优点是稳定，兼容性好，很多平台上都可以使用，包括JRuby。Swiftiply小组还写了一个利用EventMachine的Mongrel修改版，称之为Evented Mongrel，使用单线程、事件驱动方式。 Thin 利用事件驱动机制的Ruby应用服务器，并借用了Mongrel的HTTP头解析器，事件机制的部分同样是利用了EventMachine。相比Mongrel来说，稳定性和兼容性略差。例如，我在CentOS 3.2的平台上编译后启动便崩溃。 Ebb 又一个高性能的Ruby应用服务器，有多种工作模式，可以使用事件驱动机制，也可以使用线程模式。据说线程模式服务Merb（另一个Ruby的Web应用框架）可以达到更好的性能。和Thin一样，由于刚出现不久，还不是非常稳定。它要求Glibc 2以上版本，所以老版本的Linux无法使用，另外我在自己的Ubuntu 8.04上编译的版本在运行中无法正常接受链接，所以在本文中没有涉及到Ebb的测试。 性能测试 为了了解各种前、后端程序搭配的方式各自的性能如何，必须做大量的测试。下面我将我为公司做的这个项目所进行的一系列测试的结果展示出来，并做简单的分析。 我利用了Apache Benchmark（ab），对服务器端压力最大的身份验证部分进行压力测试。 注意：这些测试都相对比较简单和宽松，很多因素、细节没有考虑进去，只是作为一个参考。而且，对于不同的Rails应用、应用中的不同部分，都应该做独立的测试，来找到最合适的部署方法。 后端的测试 首先，我们先测试我们所使用的后端在同一台机器上的性能，由于前端通常通过内部环路或UNIX套接字与后端通讯，所以我没有从另外一台机器上进行测试。由于ab不能直接测试FastCGI，为了能了解FastCGI的性能，我通过Nginx来与FastCGI通讯，分别测试TCP和Unix套接字的性能，将这个测试结果做个参考。   测试机器为ThinkPad T43，Intel Pentium M 1.86G，1.5G RAM，系统为Ubuntu 8.04，内核版本为2.6.24-16。 被测试的对象的版本为： Mongrel 1.1.3，以及Evented Mongrel Thin 0.8.1(EventMachine 0.10.0) fcgi 0.8.7(Nginx 0.6.29) 以上全部使用默认配置。测试方法是从1开始，以10为步长，到500的数值，作为并发链接数，每次测试1000个请求，得到的ab的报告中取每秒的请求数作为测试的结果。 由于Ebb没有能在我的系统上成功运行起来，所以尚未得到它的数据。其中Thin还支持KeepAlive，所以单独进行了测试，由于这个服务器的应用主要是动态内容，所以后面的测试都不测KeepAlive。 测试结果如下，左边的图是点和线，为了不让画面太乱，能清晰地了解的性能情况，我取了B样条，如右图： 我们从图上，在结合一些现有的知识，可以印证一些概念： 测试的前半部分FastCGI比HTTP快的原因是： 由于FastCGI是二进制协议，避免了HTTP协议复杂的格式解析、生成的消耗——这部分内容通常由更高效的前端服务器来完成。 FastCGI与前端服务器之间建立的是持久链接，避免了大量的打开关闭套接字的操作。 我们也看到了起初支持KeepAlive的Thin处理请求的速度也很快，同样应该是得益于持久链接，减少了打开关闭套接字的操作而造成的。 两个FastCGI的测试，虽然TCP套接字的额外开销要比UNIX套接字高一点，但基本是接近的，因为这两者性能的差异与Rails应用本身的处理速度相比是很微小的。所以FastCGI无论是走TCP还是走Unix套接字性能都是接近的。 然而，当FastCGI接受的并发链接数量不断上升时，请求的处理速度不断降低，这是因为FastCGI的处理请求方式是阻塞的，每次只处理一个请求（可以从fcgi包中的代码中看出来），随着并发链接数量上升，维持链接的开销越来越大。同样的情况也发生在使用了KeepAlive的Thin中。 测试中，Mongrel的响应速度非常稳定。虽然性能在前250并发量的测试中占下风，但是随着并发链接数的上升，它利用线程的好处逐渐显现出来。Thin虽然使用了单线程，由于是基于事件驱动，与Mongrel性能相差不多，但稳定性则低了。 Evented Mongrel的性能令人印象深刻，在后半部的测试中占据了上风。同样使用了EventMachine的Thin，性能却不如它，我觉得可能在于：一、Mongrel不支持KeepAlive，Thin支持，所以需要作额外的考虑；二、可能是Mongrel的HTTP头解析器性能更好。关于第一个因素，我将最大持久链接数设为了0，最后的测试结果是比Mongrel还要低。至于进一步研究为什么，就不在本文讨论了。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

无论在IE还是FF下面，都只需要定义frame的frameborder="0"就可以实现对frame的边框的隐藏。

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

安装SQLite

SQLite 是一个轻量级的sql风格数据库.可以执行大部分sql92标准

SQLite全部安装只有244kb,包括命令行客户端和DLL文件

SQLite不用安装服务进程，就像Access数据库一样使用方便

安装只需要2个文件

1. SQLite DLL
2. SQLite command-line client for creating tables

添加sqlite3.exe 和sqlite3.dll 到系统的path下，我放在了c:\windows\system32下了

安装sqlite3-ruby.gem

gem install sqlite3-ruby

Attempting local installation of 'sqlite3'
Local gem file not found: sqlite3*.gem
Attempting remote installation of 'sqlite3'
Select which gem to install for your platform (i386-mswin32)
1. sqlite3-ruby 1.1.0 (mswin32)
2. sqlite3-ruby 1.1.0 (ruby)
3. sqlite3-ruby 1.0.1 (ruby)
...
>

选择 1 安装sqlite3-ruby 1.1.0(mswin32)

现在好像2才是sqlite3-ruby 1.1.0(mswin32),总之选择(mswin32)就对了

安装图像管理工具（也可以不用，直接用命令行也很方便）

http://sqlitebrowser.sourceforge.net/

创建数据库

进入项目所在目录，比如我的项目是testsql

d:\work\testsql>sqlite db\test.db

上面命令就在db目录下，创建了一个test.db数据库

配置database.yml文件，访问test.db数据库

development:
   adapter: sqlite3
   database: db/test.db

   #username: root
   #password:
   #host: localhost

后面如何操作，就和使用mysql数据库一样了。

建立数据表可以用db:migrate来完成

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

module Get_color
  def get_color(color)
    return color
  end
end

module Get_wheels
  def get_number_of_wheels(wheel)
    return 4 * wheel
  end
end

class Car
  @@wheel=0
  include Get_color
  include Get_wheels

end

car = Car.new()
puts car.get_color("red")
puts car.get_number_of_wheels(1)

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

class Vehicle
  def initialize(color)
    @color = color
  end

  def get_color
    return @color
  end
end

#ver = Vehicle.new("Red")
#puts ver.get_color
class Car < Vehicle
  def initialize(color)
    super(color)
  end
  def get_color
    return "Blue"
  end
end

car = Car.new("Red")
puts car.get_color

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师