无风的港湾 » 类

资深设计师Tony Ventrice解析手机游戏开发的四个层次

江小邪 — Wed, 29 Jun 2011 03:48:08 +0000

营销人员可能明白强势品牌的重要性，但却对游戏机制一无所知；程序员可能深谙强大游戏机制的意义所在，但对游戏机制的传达方式一窍不通。这样的营销人员和程序员都无法各自打造出成功的游戏。因为一款成功的游戏离不开跨领域的协调性，然而，我们经常见到情况就如上所述，游戏制作团队的成员往往只熟悉游戏设计中面向己方的专业知识，对其他学科的知识所知甚少。

此时游戏设计师的职责显得尤为关键把不同专业的观点融合为全面的设计构想。如果设计师做不到，结果就是，团队里的成员各忙各的，把时间和精力浪费在毫不相干的工作上。

游戏设计包含了几个层次的工作，且各个层次彼此不同，就如游戏的市场营销和用户界面，把这些毫不相干的层次组合起来，这看似一项艰难的任务。完成这项任务需要明白游戏设计交叉性的理论框架、形象化游戏设计方案的下滴（上滴）效应。

手机平台的两个支点

手机游戏带给玩家的融入感可能不如掌机游戏或电脑游戏那么强烈，但如果要深入研究游戏设计结构，简易的手机游戏却是个理想的探索起点。手机游戏开发之所以独特基于两点：能简则简，以量取胜。

能简则简。你可能已经听说过这么句话：一旦所有可删除的对象都被删除了，一个游戏就趋于完美了。手机平台检验了这个论断。即使是在今天这个iPhone的黎明时代，手机游戏开发者仍然不得不应对手机游戏需局限于128K空间的难题，而这128K包括了美工、代码、游戏数据、声音和其他所有游戏要素。

这种容量限制几乎足以令任何一种游戏设置寸步难行，但游戏还是顽强地活下来了，虽然硕果仅存的是些再简单不过的游戏。这些残存下来的游戏拥有高度精炼和清晰可辩的设计构架。

以量取胜。在时间相对紧凑的开发周期中，手机游戏设计师要同时开工好几个游戏，这几乎囊括所有你能想得到的游戏类型。

同时设计三四款不同的游戏，你有两个选择：要么是通过一个共同的工作期掌握所有游戏的设计进程，要么顶着令人抓狂的压力分别跟进所有游戏设计进度。以下是一些手机游戏设计的经验总结。

tetris

层次

所有游戏设计都可以划分为四个基本的层次，即：

概念
范式
机制
界面

我们以手机游戏长青树《俄罗期方块》为例，该类戏设计的四个层次如下图所示：

俄罗斯方块的四个层次

概念

组合下落方块，尽可能把方块组合成完整的一行或多行，使之被消除，以延长游戏时间。

范式

范式是玩家与游戏时需要的思维框架。范式中所列的几何空间关系模式只是简单地指代玩家可能遇到的各种益智类游戏，例如拼图游戏、魔方、《无限回廊》、《音乐方块》和《跳跳球》等等。范式中的组合构建在游戏上就是所谓的匹配消除类游戏，例如《宝石方块》、《毛毛球》和《宝石迷阵》等等。

机制

机制由游戏内容构成的；内容对于支撑范式是必不可少的。

机制是第三层次的实质，内容也是建立在机制的基础之上。在《俄罗期方块》中，可阐述的机制非常多，没有办法列出全部，省略的要点如：方块阻塞，游戏结束和下落及接触这两个动词的解释。

界面

如图可见，并非所有的机制都需要直接的用户输入。在设计良好的游戏里，界面的利用限度是最低的，但能引起机制之间的连锁反应。例如，玩家通过影响方块的下落位置，从而决定底部的方块残排能否补全。

每一款游戏都可以描述为这四个层次。以下是对四个层次的详解。

概念

对许多人来说，游戏设计的起始都伴随着一个概念即从提出初步设想到形成完整的理念。

概念本身并不能阐明游戏的乐趣所在。提出设想的人通常是在头脑中想象着其他概念相似的游戏，并且假设所有游戏辅助细节都隐含其中。

如果你是一个设计师，你就会知道概念不是重点，但并不是说一个设计师应该抛弃设想。毕竟，概念是游戏设计的最高层次；如果概念本身不能讲述引人入胜的剧情，这样的游戏也不会有市场。

曾经存在着这么些卓越的游戏，因为其概念不能与用户产生共鸣，所以盈利表现不佳。游戏续作和电影授权游戏的成功很大程度上可以归结为，其游戏概念已深入人心。

在手机游戏里，没有所谓的游戏盒子或者视频演示游戏概念只能通过游戏名称体现出来。当我参与制作一个24 TV show授权游戏时，我们团队面临的最大障碍是游戏命名的问题。

我们那时已在开发游戏续作了，我们知道第一款游戏反响不佳可能得归咎于名称，所以24 Part 2这个名称就被淘汰了。而24: Jack Bauer’s Back等此类名称显然也不是我们的选择，最后只好将游戏命名为24: Agent Down。

在本作中，游戏的理念已经体现出来了；任何看过24的人都知道它是关于间谍和阴谋、黑客和枪战的电视节目，但通过简短的描述把这个概念完整地传达给用户几乎是不可能的事情。

《ER Rush》这个名称就不错。这是一款原创、以医院为主题的转盘游戏，与成功的《美女餐厅》类似。这两款游戏虽然在许多机制颇有偏差，但基本概念却是一致的用户各取所需（游戏邦注：玩家在该游戏中的任务就是在医院里四处奔走为病人提供服务），这款游戏的市场行情也非常走俏。

要产生一个理想的概念，最重要的是鼓励大胆创新；提取出最引人注目的内容对其进行扩充；体现游戏剧情。虽然这未必可以描述游戏的最终走向，但却是定义下一步–范式的前提。

范式

范式大概是四个游戏设计基本层次中最难称呼且最容易被忽略的一个层次了。范式听起来有些虚饰和抽象，但其意义却非常具体、明确：范式是玩家作用于游戏时的展望。

每一个挑中某款游戏的玩家都会带着先入为主的观念来玩游戏，这种观念是玩家本身、玩家所处的社会和人性所固有的特点。游戏反映生活，所以大多游戏带给玩家的普遍体验都不外乎打猎、收集和建造等等，这是自然而然的事。正是这些游戏体验定义了范式。

范式包含了一系列的玩家意料之中的规则。因此无需提醒，玩家凭直觉就知道范式固有的目标和风险，例如管理资源。如果一款游戏融合了各式体验，且每种体验都有各自的小目标，那么这个游戏可以说是融合了形形色色的范式。

范式与类型相似，但类型主要根据以往的游戏来创建原型，而范式则直接涉及人类体验的基本构建模块。

从类型方面举例，第一人称射击类游戏，展现了游戏的视觉范围和目标，但没有定义明确的范式。而FPS类游戏的特色在于：缓慢的节奏（系统的/计划前瞻性）、频繁地使用掩护（躲藏和搜索），战略武器升级（资源管理）和武器在不同情景的切换（工具管理）。这些游戏过程事实上都各有其小范式（即括号内的词组），并且每一个都是玩家熟悉的经历。玩家无需得到躲藏和搜索的前提解释，因为那就是人的本能。

范式和概念经常被混淆；许多概念能立即反映一个明显的范式（如猎鹿游戏需要躲藏和搜索的游戏内容），但这并不意味着其他范式不能与之共存。

范式和游戏机制同样不易区分。第一款游戏为了展开成功的范式，通常会构建一个机制先例，而这个机制先例总是被后来的游戏效仿。例如，技巧类桌面游戏总是围绕四个键的输入组合来做文章。这就是这类游戏多年以来形成的惯例。

机制与内容

范式隐暗游戏规则，而机制决定游戏规则。在一定程度上可以说机制充当了游戏中的可操作部分。组合三个方块来消除一排或几排方块、重新装载枪支、用木材和铁搭建兵营或者其他在游戏中能做的事，这些都是一种机制。如果玩家可以改变或者影响游戏中的什么元素，那种元素就是机制。

机制具有详细性、技术性，且其细节包含的信息太多（游戏邦注：对一般人而言是如此，但游戏程序员和设计师除外）。一般人看到是本身只作为机制的集合体内容，而看不到其掩盖下的细节。

富有经验的设计师从游戏概念成形的那一刻起就在考虑游戏机制。如果有人建议做一款以玩家为上帝的游戏，且所有人都认同这是个了不起的概念，那么设计师肯定在所有人都开工前就确定好可控制的机制。

一个普遍而不言自明的手机游戏开发理念是：游戏功能和机制越多越好。这是因为游戏可玩的地方越多，游戏的价值就越大。

如果制作游戏过程不受时间、金钱和玩家注意力的限制，以上言论可能完全正确。但游戏设计师的当务之急是决定什么功能可以为整个游戏锦上添花，什么功能应该排除在外。

总体来说，设计师就像主管。想法是廉价的，但艺术构想却是无价的。程序员可以只将设计视为纯粹的机制，制作人员可以只当设计是纯粹的内容，但设计师却要把自己的视野放宽一些。

除了确定游戏的功能和特色，设计师还要凭借自己的经验和想象，将预定设想转化为赏心悦目、意义深远、一目了然的界面，且这个界面能激发玩家的凝聚力，平衡玩家的紧张感和松弛感。

界面

游戏设计层次的底层是界面。界面是有形的视听提示，是沟通玩家与游戏机制的桥梁。

界面通常是由按钮组成的，但也可能包含虚拟摇杆、鼠标、麦克风、加速计或者移动传感手套等。

界面设计至少应把输入方式与机制相对应，但还要进一步考虑界面的平衡性不可用过多输入操作吓走玩家、避免难度较大的输入组合以及过分精确的定时设置，要让游戏的基调始终如一，简单易记。

Guitar Hero World Tour

因为手机有别于其他游戏设备，所以界面就成了运行手机游戏的一大挑战。设计手机版《吉他英雄之世界巡演》时，我很快就断定增加一击鼓键与玩家习惯了的三键相比，游戏难度将大大提升。玩家经常不得不彻底改变拿手机的方式以适应击鼓输入。

为了简化这种设置，我们把下排数字键（7、8、9）设定为有效的击鼓输入，同时进一步过滤音符数据，这样鼓的轨道上就不会产生多音符弦。

事实证明，这种额外简化设置确实有助于创造吉他和鼓模式之间的独特玩法，吉他的挑战难点在于控制复杂度渐进的和弦过渡，而鼓的挑战难点则在于通过更多输入实现单音符的快速衔接。

界面会对上游层次的机制产生影响只有玩家本能地知道如何与机制互动的时候，这种设计才能生效，所以我们必须针对界面调整游戏机制。所有关于界面设计的文献得出的最终结论都是：界面设计的目标是尽可能展现一目了然的用户界面。

结论

此时你可能觉得现在已产生的问题比解决掉的问题还多。例如，如何平衡全新的概念和熟悉的概念？范式的定义应如何进一步精细化？如何组织游戏内容，才能使上层的范式和下层的机制对其产生定义作用？如何优先考虑界面的要求？

用四层次法界定游戏的好处在于它可以展示设计的结构，同时指出了一些更深层次而有待解决的问题。

事实上每一层次还各有深度：

理念借助市场营销的威力
范式需要心理学上的分析
机制是纯游戏设计的结构单元
用户界面是实用性专家的关注焦点

在一个小型手机游戏项目中，以上所述的任务很可能是设计师一个人的职责，但这也算是一种优势。当所有游戏设计的层次都为一人所掌握，那么这个人就应做出最明智、最有效的决策。如果整个团队都能理解游戏的整体状况，那么整个团队都能做出明智的决定。

本文的目的不在于解释如何设计游戏，而只是提供游戏设计的思路。解决了这四个层次的问题也还只是设计游戏的开端，但至少可以指引你朝着正确的方向前进，而不至于迷失方向。

odex相关知识

江小邪 — Wed, 29 Jun 2011 03:40:48 +0000

Android的ROM中有很多odex文件，相对于APK中的dex文件而言这个odex有什么作用呢? 如果你仔细观察会发现文件名时一一对应的，同时那些对应的apk文件中没有dex文件。这样做可以使其厂商保证一定的反盗版，因为没有没有dex文件的apk是无法正常安装的，而厂商直接将odex和不完整的apk文件放到手机rom固化到/system/bin中可以让一般用户无法正常导出使用

可能想到的是合并odex和apk变成apk中包含dex文件的，这样合并后最终apk文件安装在/data/中，而rom存放在 /system/app中，所以最终导致了用户可装在Android手机中的软件会变少，占用系统空间。

一、APK生成odex文件方法:

编译开源GIT上的build/tools/dexpreopt/dexopt-wrapper这个，使用dexopt-wrapper即可，操作步骤

将dexopt-wrapper放到/data/local目录中，使用adb shell执行linux命令行，使用cd命令进入/data/local目录，

cd /data/local

./dexopt-wrapper android123.apk android123.odex

二、合并odex和少dex的apk 为完整的apk文件

1. 下载 http://smali.googlecode.com/files/smali-1.2.2.jar 和http://smali.googlecode.com/files/baksmali-1.2.2.jar，既然是需要盗版，还需要odex所在rom中的一些引用类，一般在 /system/framework 目录中

2 . 通过odex生成class文件

java -jar baksmali-1.2.2.jar -x android123.odex

执行完上面这行命令后，会生成一个out 文件夹里面是android123.odex的class文件。出现问题，根据提示可以从rom的 /system/framework 中的xxx.jar放到pc上的java环境变量中一起生成。

3. 通过class生成classes.dex 文件。

java -Xmx512M -jar smali-1.2.2.jar out -o classes.dex

4. 将classes.dex放到apk文件

因为apk是zip的mime编码类型，使用winzip或winrar直接拖入到apk改名为zip的

ASP防注入新方式，希望对大家是有用的

江小邪 — Wed, 28 Jul 2010 02:00:27 +0000

最近我的网站经常把js脚本注入到数据，清除了又来。先后在网上找了很多的方法，还是没有用的，十分恼火。

首先先告诉大家一个批量清除代码的sql语句。

update 表名 set 字段=replace(字段,’script src=http://3b3.org/c.js>
1、分析那些无聊的人，或者有些病态的人究竟做了些什么。

通过iis的日志或者microsoft urlscan 日志查看，在一些通过id查询数据库内容的时候后面被人加了一段很长的字符窜。

%%3B%%44%%65%%43%%4C%%61%%52%%45%%类似这样的字符窜，一定是其他的方式编码

首先我们先用工具分析下如此之长的字符窜究竟包含了些什么内容。

通过批量替换工具把%%全部替换成空，然后把得到的字符串通过其他的转码工具，转成字符窜。

;DeCLaRE @S NvArCHaR(4000);SeT @S=CaSt(0×45这里代码去掉了06F007200 aS NvArChAR(4000));ExEc(@S);–

就是一段与通过id查询数据库同时执行的sql，就给数据库某些表的字段加入了js病毒连接。

2、所以我们的原来的防sql注入的字符串就需要升级了。

如果过滤16进制

; 对应 3B

DeCLaRE 对应 4465434C615245

@ 对应 40

NvArCHaR 对应 4E76417243486152

set 对应 536554

CaSt 对应 43615374

as 对应 6153

exec 对应 45784563

- 对应 2D

把16进制的代码用|隔开放到injdata 里面

injdata = “3B|2D|’|;|and|exec|insert|select|delete%20from|update|count|”

然后自己测试下，程序是否拦击了这些16进制的代码，本人测试过是可以拦击的，如果不加入这些是不拦击的

照样可以注入到数据库。

完美解决“由于这台计算机没有终端服务器客户端访问许可证”

江小邪 — Wed, 28 Jul 2010 01:29:01 +0000

由于windows2003默认仅支持2个终端用户的登陆。当“终端连接超出了最大连接”的情况出现导致不能登录时，可以：

1、在另外一台Windows2003的机器上运行“tsmmc.msc”，打开远程桌面连接，添加一个新的连接，输入远程服务器的IP地址、远程登录帐号和密码，登录到远程服务器桌面。这个方式可以随时登录到远程桌面。

2、在登录出问题的服务器上，单击“开始”，指向“管理工具”，然后单击“终端服务配置”。

3、单击“服务器设置”，然后双击“授权模式”。

4、将“授权模式”更改为“每用户”，然后单击“确定”。以后就不会出现此类问题了。

原因：Window Server 2003 不管理“用户 CAL”。这就是说，即使许可证服务器数据库中有一个“用户 CAL”，它在被使用时也不会减少。这样就不会为了让每个用户都有一个有效的终端服务器 (TS) CAL 而根据“最终用户许可协议”(EULA) 的要求删除管理员。在没有使用“设备 CAL”的情况下，如果不是每个用户都有一个“用户 CAL”，就会违反 EULA。

PHP和Socket简介

江小邪 — Sun, 25 Jul 2010 17:19:26 +0000

Sockets在PHP中是没有充分利用的功能。今天你将看到产生一个能使用客户端连接的服务器，并在客户端使用socket进行连接，服务器端将详细的处理信息发送给客户端。

当你看到完整的socket过程，那么你将会在以后的程序开发中使用它。这个服务器是一个能让你连接的HTTP服务器，客户端是一个Web浏览器，这是一个单一的客户端/服务器的关系。

◆　Socket 基础

PHP使用Berkley的socket库来创建它的连接。你可以知道socket只不过是一个数据结构。你使用这个socket数据结构去开始一个客户端和服务器之间的会话。这个服务器是一直在监听准备产生一个新的会话。当一个客户端连接服务器，它就打开服务器正在进行监听的一个端口进行会话。这时，服务器端接受客户端的连接请求，那么就进行一次循环。现在这个客户端就能够发送信息到服务器，服务器也能发送信息给客户端。

产生一个Socket，你需要三个变量：一个协议、一个socket类型和一个公共协议类型。产生一个socket有三种协议供选择，继续看下面的内容来获取详细的协议内容。

定义一个公共的协议类型是进行连接一个必不可少的元素。下面的表我们看看有那些公共的协议类型。

表一：协议

名字/常量描述
AF_INET 这是大多数用来产生socket的协议，使用TCP或UDP来传输，用在IPv4的地址
AF_INET6 与上面类似，不过是来用在IPv6的地址
AF_UNIX 本地协议，使用在Unix和Linux系统上，它很少使用，一般都是当客户端和服务器在同一台及其上的时候使用

表二：Socket类型

名字/常量描述
SOCK_STREAM 这个协议是按照顺序的、可靠的、数据完整的基于字节流的连接。这是一个使用最多的socket类型，这个socket是使用TCP来进行传输。
SOCK_DGRAM 这个协议是无连接的、固定长度的传输调用。该协议是不可靠的，使用UDP来进行它的连接。
SOCK_SEQPACKET 这个协议是双线路的、可靠的连接，发送固定长度的数据包进行传输。必须把这个包完整的接受才能进行读取。
SOCK_RAW 这个socket类型提供单一的网络访问，这个socket类型使用ICMP公共协议。（ping、traceroute使用该协议）
SOCK_RDM 这个类型是很少使用的，在大部分的操作系统上没有实现，它是提供给数据链路层使用，不保证数据包的顺序

表三：公共协议

名字/常量描述
ICMP 互联网控制消息协议，主要使用在网关和主机上，用来检查网络状况和报告错误信息
UDP 用户数据报文协议，它是一个无连接，不可靠的传输协议
TCP 传输控制协议，这是一个使用最多的可靠的公共协议，它能保证数据包能够到达接受者那儿，如果在传输过程中发生错误，那么它将重新发送出错数据包。

现在你知道了产生一个socket的三个元素，那么我们就在php中使用socket_create()函数来产生一个socket。这个 socket_create()函数需要三个参数：一个协议、一个socket类型、一个公共协议。socket_create()函数运行成功返回一个包含socket的资源类型，如果没有成功则返回false。
Resourece socket_create(int protocol, int socketType, int commonProtocol);

现在你产生一个socket，然后呢？php提供了几个操纵socket的函数。你能够绑定socket到一个IP，监听一个socket的通信，接受一个socket；现在我们来看一个例子，了解函数是如何产生、接受和监听一个socket。

php
$commonProtocol = getprotobyname(“tcp”);
$socket = socket_create(AF_INET, SOCK_STREAM, $commonProtocol);
socket_bind($socket, ‘localhost’, 1337);
socket_listen($socket);
// More socket functionality to come
?>

上面这个例子产生一个你自己的服务器端。例子第一行，
$commonProtocol = getprotobyname(“tcp”);
使用公共协议名字来获取一个协议类型。在这里使用的是TCP公共协议，如果你想使用UDP或者ICMP协议，那么你应该把getprotobyname() 函数的参数改为“udp”或“icmp”。还有一个可选的办法是不使用getprotobyname()函数而是指定SOL_TCP或SOL_UDP在 socket_create()函数中。

$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);

例子的第二行是产生一个socket并且返回一个socket资源的实例。在你有了一个socket资源的实例以后，你就必须把socket绑定到一个IP地址和某一个端口上。

socket_bind($socket, ‘localhost’, 1337);

在这里你绑定socket到本地计算机（127.0.0.1）和绑定socket到你的1337端口。然后你就需要监听所有进来的socket连接。

socket_listen($socket);

在第四行以后，你就需要了解所有的socket函数和他们的使用。

表四：Socket函数

函数名描述
socket_accept() 接受一个Socket连接
socket_bind() 把socket绑定在一个IP地址和端口上
socket_clear_error() 清除socket的错误或者最后的错误代码
socket_close() 关闭一个socket资源
socket_connect() 开始一个socket连接
socket_create_listen() 在指定端口打开一个socket监听
socket_create_pair() 产生一对没有区别的socket到一个数组里
socket_create() 产生一个socket，相当于产生一个socket的数据结构
socket_get_option() 获取socket选项
socket_getpeername() 获取远程类似主机的ip地址
socket_getsockname() 获取本地socket的ip地址
socket_iovec_add() 添加一个新的向量到一个分散/聚合的数组
socket_iovec_alloc() 这个函数创建一个能够发送接收读写的iovec数据结构
socket_iovec_delete() 删除一个已经分配的iovec
socket_iovec_fetch() 返回指定的iovec资源的数据
socket_iovec_free() 释放一个iovec资源
socket_iovec_set() 设置iovec的数据新值
socket_last_error() 获取当前socket的最后错误代码
socket_listen() 监听由指定socket的所有连接
socket_read() 读取指定长度的数据
socket_readv() 读取从分散/聚合数组过来的数据
socket_recv() 从socket里结束数据到缓存
socket_recvfrom() 接受数据从指定的socket，如果没有指定则默认当前socket
socket_recvmsg() 从iovec里接受消息
socket_select() 多路选择
socket_send() 这个函数发送数据到已连接的socket
socket_sendmsg() 发送消息到socket
socket_sendto() 发送消息到指定地址的socket
socket_set_block() 在socket里设置为块模式
socket_set_nonblock() socket里设置为非块模式
socket_set_option() 设置socket选项
socket_shutdown() 这个函数允许你关闭读、写、或者指定的socket
socket_strerror() 返回指定错误号的详细错误
socket_write() 写数据到socket缓存
socket_writev() 写数据到分散/聚合数组

(注: 函数介绍删减了部分原文内容，函数详细使用建议参考英文原文，或者参考PHP手册)

以上所有的函数都是PHP中关于socket的，使用这些函数，你必须把你的socket打开，如果你没有打开，请编辑你的php.ini文件，去掉下面这行前面的注释：
extension=php_sockets.dll
如果你无法去掉注释，那么请使用下面的代码来加载扩展库：

if(!extension_loaded(‘sockets’))
{
if(strtoupper(substr(PHP_OS, 3)) == “WIN”)
{
dl(‘php_sockets.dll’);
}
else
{
dl(‘sockets.so’);
}
}
?>

如果你不知道你的socket是否打开，那么你可以使用phpinfo()函数来确定socket是否打开。你通过查看phpinfo信息了解socket是否打开。

查看phpinfo()关于socket的信息

◆　产生一个服务器

现在我们把第一个例子进行完善。你需要监听一个指定的socket并且处理用户的连接。

$commonProtocol = getprotobyname(“tcp”);
$socket = socket_create(AF_INET, SOCK_STREAM, $commonProtocol);
socket_bind($socket, ‘localhost’, 1337);
socket_listen($socket);
// Accept any incoming connections to the server
$connection = socket_accept($socket);
if($connection)
{
socket_write($connection, “You have connected to the socket…\n\r”);
}
?>

你应该使用你的命令提示符来运行这个例子。理由是因为这里将产生一个服务器，而不是一个Web页面。如果你尝试使用Web浏览器来运行这个脚本，那么很有可能它会超过30秒的限时。你可以使用下面的代码来设置一个无限的运行时间，但是还是建议使用命令提示符来运行。

set_time_limit(0);

在你的命令提示符中对这个脚本进行简单测试：

Php.exe example01_server.php

如果你没有在系统的环境变量中设置php解释器的路径，那么你将需要给php.exe指定详细的路径。当你运行这个服务器端的时候，你能够通过远程登陆（telnet）的方式连接到端口1337来测试这个服务器。

上面的服务器端有三个问题：1. 它不能接受多个连接。2. 它只完成唯一的一个命令。

3. 你不能通过Web浏览器连接这个服务器。

这个第一个问题比较容易解决，你可以使用一个应用程序去每次都连接到服务器。但是后面的问题是你需要使用一个Web页面去连接这个服务器，这个比较困难。你可以让你的服务器接受连接，然后些数据到客户端（如果它一定要写的话），关闭连接并且等待下一个连接。

在上一个代码的基础上再改进，产生下面的代码来做你的新服务器端：

// Set up our socket
$commonProtocol = getprotobyname(“tcp”);
$socket = socket_create(AF_INET, SOCK_STREAM, $commonProtocol);
socket_bind($socket, ‘localhost’, 1337);
socket_listen($socket);
// Initialize the buffer
$buffer = “NO DATA”;
while(true)
{
// Accept any connections coming in on this socket

$connection = socket_accept($socket);
printf(“Socket connected\r\n”);
// Check to see if there is anything in the buffer
if($buffer != “”)
{
printf(“Something is in the buffer…sending data…\r\n”);
socket_write($connection, $buffer . “\r\n”);
printf(“Wrote to socket\r\n”);
}
else
{
printf(“No Data in the buffer\r\n”);
}
// Get the input
while($data = socket_read($connection, 1024, PHP_NORMAL_READ))
{
$buffer = $data;
socket_write($connection, “Information Received\r\n”);
printf(“Buffer: ” . $buffer . “\r\n”);
}
socket_close($connection);
printf(“Closed the socket\r\n\r\n”);
}
?>

这个服务器端要做什么呢？它初始化一个socket并且打开一个缓存收发数据。它等待连接，一旦产生一个连接，它将打印“Socket connected”在服务器端的屏幕上。这个服务器检查缓冲区，如果缓冲区里有数据，它将把数据发送到连接过来的计算机。然后它发送这个数据的接受信息，一旦它接受了信息，就把信息保存到数据里，并且让连接的计算机知道这些信息，最后关闭连接。当连接关闭后，服务器又开始处理下一次连接。

◆　产生一个客户端

处理第二个问题是很容易的。你需要产生一个php页连接一个socket，发送一些数据进它的缓存并处理它。然后你又个处理后的数据在还顿，你能够发送你的数据到服务器。在另外一台客户端连接，它将处理那些数据。

下面的例子示范了使用socket：

// Create the socket and connect
$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
$connection = socket_connect($socket,’localhost’, 1337);
while($buffer = socket_read($socket, 1024, PHP_NORMAL_READ))
{
if($buffer == “NO DATA”)
{
echo(“

NO DATA

”);
break;
}
else
{
// Do something with the data in the buffer
echo(“

Buffer Data: “ . $buffer . “

”);
}
}
echo(“

Writing to Socket

”);
// Write some test data to our socket
if(!socket_write($socket, “SOME DATA\r\n”))
{
echo(“

Write failed

”);
}
// Read any response from the socket
while($buffer = socket_read($socket, 1024, PHP_NORMAL_READ))
{
echo(“

Data sent was: SOME DATA
Response was:” . $buffer . “

”);
}
echo(“

Done Reading from Socket

”);
?>

这个例子的代码演示了客户端连接到服务器。客户端读取数据。如果这是第一时间到达这个循环的首次连接，这个服务器将发送“NO DATA”返回给客户端。如果情况发生了，这个客户端在连接之上。客户端发送它的数据到服务器，数据发送给服务器，客户端等待响应。一旦接受到响应，那么它将把响应写到屏幕上。

php的文档句法(heredoc)

江小邪 — Sun, 25 Jul 2010 17:18:49 +0000

不多说了，看代码。自己体会

php
echo “濙水河边的PHP演示”;
echo “
”;
$db=mysql_connect(“localhost”,”root”,”123456″);
mysql_select_db(“jaycee”,$db);
$rs=mysql_query(“select * from gbook”,$db);
while($row=mysql_fetch_row($rs))
{
echo <<< eod

$row[0]	$row[1]
$row[2]	$row[3]

eod;
}
?>

<<<也就是可以让我们在PHP代码内实现一大段的HTML代码，并且可以在其中，使用PHP变量。

淡水河边这厮，找到许多PHP入门呀，php起步呀＝＝的书，从没提到用到这个。郁闷，用不到么？

居然不提。愤怒！

淡水河边看的书上叫它文档句法,又称定界符.它的语法是”<<<”。用法是在其后提供一个标识符，然后在标识符后提供字符串，再在字符串后提供此标识符来结尾。注意，淡水河边这厮这里用的标志符是EOD，结束的那个标志要顶头写，不能有缩进和空格.

字符串的操作

1. 字符串的表现形式

在大部分语言里，双引号是字符串，单引号是字符。但是在PHP里，字符串的表现形式有3种。即：

单引号

双引号

定界符（heredoc syntax）

看见了吧，单引号居然可以用来表示字符串。那么如果我想表示单引号怎么办？和大多数语言一样，使用转义符号吧。即反斜线”\”.那么使用单引号和双引号有什么区别呢？我的观点是没有多大区别。唯一的区别就是双引号可以应用更多的转义符。
让我们定界符吧。它的语法是”<<<”。用法是在其后提供一个标识符，然后在标识符后提供字符串，再在字符串后提供此标识符来结尾。例如：

$str= << Hello, this is an example for HEREDOC Syntax.
Please attention to it.
EOD;
echo $str;
?>

注意，这里的提供的标志符是EOD，中间的是字符串。

2. 字符串的特别之处

从一个例子开始。

假设里你有很长的一段字符串，比如一段话。几个月后，你发现你的需求改变，需要在这段话的某个位置插入一个变量。这个时候如果重新用字符串符肯定是相当复杂的。那么有没有其他的方法呢？请放心，PHP已经考虑到这一点了。那就是花括号的应用。

对于PHP，它一般会按照如下规则解析：

如果遇到美元符号（$），解析器会尽可能多地取得后面的字符以组成一个合法的变量名。如果想明示指定名字的结束，用花括号把变量名括起来。例如

$beer = “Heineken”;
echo “$beer”s taste is great”; // works, “”" is an invalid character for varnames
echo “He drank some $beers”; // won”t work, “s” is a valid character for varnames
echo “He drank some ${beer}s”; // works
echo “He drank some {$beer}s”; // works
?>

看看第3，4行。第三行的$beer”s其实是$beer 后加“‘s”。因为这里的“’”对于变量命名来说是一个无效字符。但是第4行的$beers就不一样了。所以$beers是无效的。
除了上面的,你还会注意到地5，6行的${beer}以及{$beer｝。对于PHP来说它们都是合法的。

但是你必须注意一点，${beer}以及{$beer｝的$和｛必须是紧挨的。不然｛就会当成｛字符看待了。

3，字符串的常用操作。

我想这是令我们异常激动的一个话题，并且也是非常实用的。

字符串的函数比较多，我们还是介绍一部分函数吧。

字符串的整理函数

chop(),其实就是rtrim().当然rtrim()还是可以用的

ltrim(),去掉字符串左边的多于空格。

trim(),这个比较比较简单，就是把字符串左右2边的空格都给删除。

字符串的格式化输出

实用HTML格式化的。nl2br().即在字符串的新一行前插入
.

echo nl2br(“foo isn”t\n bar”);
?>

上面的字符串会分2行显示，如果把此函数去掉，就只在一行上显示了。

打印输出的格式化。

PHP支持print()函数，它和echo一样，唯一的差别就是print()返回一个整型值，一直为1。除了print(),还有printf()和sprintf(). 写到这里，你肯定会想，怎么和C一样呢。它们的工作方式一样，差别是printf()将结果输出到浏览器，而sprintf()这是输出到变量。

看看它们的定义吧。

int printf ( string format [, mixed args [, mixed ]] )

string sprintf ( string format [, mixed args [, mixed ]] )

改变字符串的大小写。

strtolower将字符串变为小写

strtoupper将字符串变为大写

ucfirst将字符串的第一个字符大写。

ucwords 将字符串中的每一个单词的第一个字符变为大写。

格式化字符，以便存储。

其实就是为了替换引号，反斜杠，NULL等，因为它们有的时候不适合于很多场合，比如存储到数据库。为了达到目的，addslashes是一个不错的选择，它使用反斜线引用字符串。为了在显示数据，需要在之前调用stripslashes，否则反斜杠会显示出来的。

字符串比较

strcmp,strcasecmp,strnatcmp,有时间再查一下

字符串长度请调用strlen.

字符串连接与分割

explode类似于C#里的Split函数。例如：

$str = “Is yours name reilly?”;
$var=explode(” “,$str);
echo $var[0];//输出：Is
echo $var[1];//输出:yours
?>

implode()和join()提供的功能一样，正好与explode()相反，它们将多个字符换合并起来。

strtok()和split类似，但是它一次只取出一个。

为了取得子字符串，调用substr()吧。

查找字符串中的字符串

可以调用strstr(),strchr(),strrchr()以及stristr().记住，strchr()是strstr()的别名，查找第一次出现的地方。strrchr()，查找最后一个字符串出现的地方。

stristr()和strstr()的区别是前者不区分大小写。

查找字符串的位置可以使用strpos()以及strrpos().

替换的话，调用str_replace()以及substr_replace().

以上介绍都是最常用的，如果想得到更多字符串的函数以及函数的信息，参考PHP的函数文档。

PHP对文本数据库的基本操作方法

江小邪 — Sun, 25 Jul 2010 16:56:38 +0000

PHP实现对文本数据库的数据显示、加入、修改、删除、查询五大基本操作的方法
我用一个留言本程序作为例子，阐述PHP实现对文本数据库的数据显示、加入、修改、删除、查询五大基本操作的方法。
此文本数据库共有字段10个：客户IP、发言时间、客户名、客户EMAIL、客户主页地址、留言表情图片名、客户QQ、客户形象图片、留言内容、管理员回复内容。

1、加入数据程序段。

$date=date(“Y-m-d H:i:s”);//取得系统时间
$ip = $HTTP_SERVER_VARS[REMOTE_ADDR]; //取得发言的IP地址
$text=encode($gb_text);//去掉留言内容后面的空格.
$fp=fopen(“gb.dat”,”a”);//以只写模式打开gb.dat文本文件,文件指针指向文件尾部.
$str=$ip.”　”.$date.”　”.$gb_name.”　”.$gb_email.”　”.$gb_home.”　”.$face.”　”.$gb_qq.”　”.$head.”　”.$text.”　”.$reply.”\n”;//将所有留言的数据赋予变量$str，”　”的目的是用来今后作数据分割时的数据间隔符号。
fwrite($fp,$str);//将数据写入文件
fclose($fp);//关闭文件
showmessage(“留言成功!”,”index.php”,”3″);//留言成功，3秒后自动返回主界面。
其中的$gb_name 、$gb_email、$gb_home、$face、$gb_qq、$head、$gb_text、$reply是由发言表单传过来的数据。

2、数据显示程序段

＜?
if (file_exists(“gb.dat”)){//检测文件是否存在
$array=file(“gb.dat”);//将文件全部内容读入到数组$array
$arr=array_reverse($array);//将$array里的数据安行翻转排列（即最后一行当第一行，依此类推）读入数组$arr的每一个单元（$arr[0]…）。
$num=count($array);//获取数组$array里的信息数(一行为一条信息)
if ($num＞0){//如果信息数大于零（即文本数据库不为空）
$total=ceil($num/$pagesize);//计算总页数(取最大整数,即凡有小数点都进一取整，$pagesize为预设的每页显示的信息数)
if($page＜1){//如果当前页面数码号小于1
$page=1;//则赋值为1
}
$number=($page-1)*$pagesize;//计算当前所显示第一个留言的数码号（数码号从零开始，主要是达到与数组单元号对应的目的）
for($i=0;$i＜=$pagesize-1;$i++){//进入循环
$row=explode(“　”,$arr[$number]);//以”　”作为分割符,分割数组$arr中每第$number个单元的数据,并将这些数据赋予数组$rom
list($ip,$datetime,$name,$email,$home,$face,$qq,$head,$text,$reply)=$row;//将数组$row里的单元数据按顺序赋予括号里的变量
?＞
＜img src=＜? echo $head ?＞＞//显示客户形象图片
＜br＞
＜font color=”#0099CC”＞昵称【＜? echo $name ?＞＜font size=”2″＞】＜br＞//显示客户名
发表于：＜? echo $datetime ?＞//显示留言发表时间
＜br＞
＜img src=＜? echo $face ?＞＞//显示客户留言表情图片
＜? echo $name ?＞说:＜? echo $text; ?＞//显示客户留言内容
＜br＞
＜? echo $reply ?＞//显示回复内容
＜br＞

＜a href=”＜? echo $home ?＞” target=”_blank”＞访问＜? echo $name ?＞的主页＜/a＞//客户主页的超连接
＜a href=”mailto:＜? echo $email ?＞”＞给＜? echo $name ?＞发信＜/a＞//客户E-MAIL的连接
＜? echo $name ?＞的QQ号码是＜? echo $qq ?＞//显示客户的QQ号码
＜? echo $name ?＞的IP地址为＜? echo $ip ?＞” //显示客户的IP地址
＜a href=”reply.php?time=＜? echo $datetime ?＞”＞回复＜/a＞//留言回复的连接语句
＜a href=”del.php?time=＜? echo $datetime ?＞”＞删除＜/a＞//留言删除的语句（以客户留言时间$datetime作为删除标识）
＜br＞
＜?
if ($number == $num-1)//如果数组的单元号等于总留言数减一（因为单元号以零开始的，所以这意味着这是最后一条留言）
{
break;//跳出循环
}
$number = $number + 1; //数组单元号加1
}//循环结束符
}
if ($page ＜＞ 1)//如果当前页面数码号不等于1
{
$back = $page – 1;//当前页面数码号减1，并将此值赋予变量$back
echo “＜a href=index.php?page=1＞第一页＜/a＞”;//显示第一页的连接
echo ” ＜a href=index.php?page=$back＞上一页＜/a＞” ;当前页面数码号等于$back，并显示其连接
}
if ($page ＜＞ $total)//如果当前页面数码号不等于总页数号（最后一页数码号）
{
$next = $page + 1;//当前页面数码号加1并赋予变量$next
echo ” ＜a href=index.php?page=$next＞下一页＜/a＞” ;//显示下一页连接
echo ” ＜a href=index.php?page=$total＞最后一页＜/a＞”; 显示最后一页连接
}
echo “页数：$page / $total”;//显示当前页面数码号和显示最后一页数码号
echo “共有 $num 条留言”;//显示留言数信息
}
else {
echo “＜center＞当前没有任何留言！＜/center＞”;//如果文件内容为空则显示的信息
}
else {
echo “＜center＞数据文件丢失，请联系管理员！或发布留言重新建立数据文件！＜/center＞”;//如果文件不存在显示的信息
}

3、数据修改程序段

$fp=fopen(“gb.dat”,”w”);//则以只写模式打开文件gb.dat
$gb_reply=encode($gb_reply);
for ($i=0;$i＜$n;$i++) {//进入循环
if(eregi($ttime,$list[$i])){//将送来发留言时间$ttime与数组单元$list里内容进行字串匹配比较
$f=explode(“　”,$list[$i]);//如果找到匹配，就以”　”作为分隔符,切开留言信息$list[$i](第$i条留言),并将这些数据赋予数组$f
$f[9]=$gb_reply;//将$f[9]（留言信息最后一条数据）用$gb_reply（回复内容）代替。
$list[$i]=$f[0].”　”.$f[1].”　”.$f[2].”　”.$f[3].”　”.$f[4].”　”.$f[5].”　”.$f[6].”　”.$f[7].”　”.$f[8].”　”.$f[9].”\n”; //将数组单元$list[$i]的内容用数组$f加上分隔符”　”代替（其中$f[9]是修改了的新数据）。
break;//跳出循环
}
}//循环结束符
}
FOR($i=0;$i＜=$n;$i++){//进入循环
fwrite($fp,$list[$i]);//将数组$list的每个单元为一行，写入文件gb.dat
}//循环结束符
fclose($fp);//关闭文件
showmessage(“回复成功!”,”index.php”);//回复成功，自动返回主界面。

4、数据删除程序段

$list=file(“gb.dat”);//读取整个gb.dat文件到数组$list,数组每一个元素为一条留言($list[0]是第一条留言的数据、$list[1]是第一条留言的数据…..
$n=count($list);//计算$list内容里的留言总数,并赋予变量$n
if ($n＞0){//如果留言数大于0
$fp=fopen(“gb.dat”,”w”);//则以只写模式打开文件gb.dat
for ($i=0;$i＜$n;$i++) {//进入循环
if(eregi($ttime,$list[$i])){//将发送过来发留言时间$ttime与数组$list[$i]里的字串进行匹配比较
$list[$i]=”";//如果匹配成功，则将$list[$i]清空（达到删除的目的）
break;//跳出循环
}
}//循环结束符
FOR($i=0;$i＜=$n;$i++){//进入循环
fwrite($fp,$list[$i]);//将数组$list的每个单元为一行，写入文件gb.dat
} //循环结束符
fclose($fp);//关闭文件
showmessage(“删除成功!”,”index.php”);//删除成功，自动返回主界面。
}

5、数据查询程序段

＜form action=”search.php” method=”post”＞
＜font color=”#0099CC” size=”2″＞搜索关键字：
＜input name=”found” type=”text” id=”found” style=”background-color:#FFFFFF; color:#8888AA; border: 1 double #3399CC” size=”12″＞
＜input name=”submit” type=”image” src=”image/search.gif” alt=”留言搜索”＞
＜/font＞＜/td＞

＜/tr＞
＜/table＞
＜/form＞
////////////////////////////////上面是搜索表单语句段
＜?
$id=0;
$list=file(“gb.dat”);//读取整个gb.dat文件到数组$list,数组每一个元素为一条留言($list[0]是第一条留言的数据、$list[1]是第一条留言的数据…..
$n=count($list);//计算$list内容里的留言总数,并赋予变量$n
$found=trim($found);
if (!$found){ //如果$found为假
echo “＜center＞您没有输入任何关键字！＜/center＞”;//作相关显示
}
else {
if($n＞0){//如果留言数大于0
for ($i=0;$i＜$n;$i++) {//进入循环
if(eregi($found,$list[$i])){//输入的关键字与数组$list[$i]里的字串进行匹配比较
$row=explode(“　”,$list[$i]); $id=1; //如果找到匹配，就以”　”作为分隔符,切开留言信息$list[$i](第$i条留言),并将这些数据赋予数组$row.并将变量$id赋予1，以便作为是否找到匹配的判断。
list($ip,$datetime,$name,$email,$home,$face,$qq,$head,$text,$reply)=$row;//将数组$row里的单元数据按顺序赋予括号里的变量
?＞
＜img src=＜? echo $head ?＞＞//显示客户形象图片
＜br＞
＜font color=”#0099CC”＞昵称【＜? echo $name ?＞＜font size=”2″＞】＜br＞//显示客户名
发表于：＜? echo $datetime ?＞//显示留言发表时间
＜br＞
＜img src=＜? echo $face ?＞＞//显示客户留言表情图片
＜? echo $name ?＞说:＜? echo $text; ?＞//显示客户留言内容
＜br＞
＜? echo $reply ?＞//显示回复内容
＜br＞
＜a href=”＜? echo $home ?＞” target=”_blank”＞访问＜? echo $name ?＞的主页＜/a＞//客户主页的超连接
＜a href=”mailto:＜? echo $email ?＞”＞给＜? echo $name ?＞发信＜/a＞//客户E-MAIL的连接
＜? echo $name ?＞的QQ号码是＜? echo $qq ?＞//显示客户的QQ号码
＜? echo $name ?＞的IP地址为＜? echo $ip ?＞” //显示客户的IP地址
＜a href=”reply.php?time=＜? echo $datetime ?＞”＞回复＜/a＞//留言回复的连接语句
＜a href=”del.php?time=＜? echo $datetime ?＞”＞删除＜/a＞//留言删除的语句（以客户留言时间$datetime作为删除标识）
＜br＞
＜?
}
}//循环结束符
}}
if($id==0){ echo “＜center＞没有找到与关键字匹配的留言！＜/center＞”;}//如果$id＝0则表示没找到匹配，显示相关提示
?＞

require和include的异同

江小邪 — Sun, 25 Jul 2010 16:55:41 +0000

第一点：require() 和 include() 除了怎样处理失败之外在各方面都完全一样。include() 产生一个警告而 require() 则导致一个致命错误。换句话说，如果你想在丢失文件时停止处理页面，那就用require() 吧，它直接会中止脚本。而include() 就不是这样，脚本会继续运行，但是会抛出一个Notice级别的错误。同时也要确认设置了合适的include_path。

就是说再解析程序时即读取require的文件，而不是解析后，如果不能读取到被require的文件，就不能进行下一步动作。所以，不被正确包含就会导致程序的文件，用require比较好。

第二点：require() 无论如何都会包含文件，而 include() 可以有选择地包含：

比如上面这段代码，a.php一定会被包含，而b.php一定不会被包含。require类似于一次预扫描，在程序执行时，无论在函数里或是函数外，都将先把require的文件执行，且只执行一次。而include则是每执行一次就调用一次文件，即这次执行后，下次再执行执行到这里，仍将再执行一次。大家应该明白这个区别了吧：）

同时可以看下require_once和include_once的区别。
require_once() 语句在脚本执行期间包括并运行指定文件。此行为和 require() 语句类似，唯一区别是如果该文件中的代码已经被包括了，则不会再次包括。
include_once() 语句在脚本执行期间包括并运行指定文件。此行为和 include() 语句类似，唯一区别是如果该文件中的代码已经被包括了，则不会再次包括。如同此语句名字暗示的那样，只会包括一次。

第二点：require() 无论如何都会包含文件，而 include() 可以有选择地包含：

AJAX的各种控件和类库

江小邪 — Sun, 25 Jul 2010 16:49:49 +0000

Ajax控件和类库现在真的太多了，不知不觉中增加了Ajax的神秘性和复杂性，看到版内很多人为此费解和伤神，决定发此贴谈谈本人对Ajax的观点，希望能让大家对Ajax有一个本质的认识。

　　观点一：Ajax和服务器端技术毫不相关

　　严格的说，与传统web开发相比，Ajax是完完全全的客户端技术。由于很多控件封装了客户端和服务器端的通信过程，因此很多问题也因通信而起。事实上，不论何种Ajax技术，服务器端都是返回的一个纯文本流，再由客户端来处理这个文本。这段文本可以是xml格式，也可以是一个Html片段，也可以是一段JavaScript脚本，或者仅是一个字符串。服务器端仅仅是作为一个数据接口，客户端使用XMLHttpRequest对象来请求这个页面，服务器端在页面内写入结果文本，这个过程和普通的web开发没有任何区别。所不同的只是，客户端在异步获取结果后，不是直接显示在页面，而是由客户端的Javascript脚本处理后再显示在页面。至于各种控件所谓的能返回DataSet对象，Date对象，或者其他的数据类型，都是封装了这个处理过程的结果。

　　观点二：DOM模型是Ajax最本质的技术

　　之所以没有把XMLHttpRequest列为最本质的技术，因为本人觉得它实在是太简单了，它只是可以让浏览器在后台请求一个页面，并将其内容交给JavaScript处理。真正的核心应该是：DOM模型，即文档对象模型。在DOM模型里，Html标记都被认为是一个对象，例如：div对象，table对象等等。DOM模型就规定了这些对象所具有的属性、方法和事件。通过这些性质，可以对一个已经显示于浏览器的页面进行内容的修改，例如增加节点、修改节点位置，删除节点等等。而不仅仅是一个innerHTML属性这么简单，虽然这是一个很有用的属性。

　　观点三：在使用Ajax控件前理解它们的实现

　　使用Ajax控件的确可以提高效率，但如果你空中楼阁般使用控件，那就得不偿失了。从一个控件换到另外一个控件又会有一个漫长的学习曲线。所以应该从底层了解其，况且Ajax实在不是什么高深的技术。其实任何东西的最底层其实都是简单的，但如果封装了这些底层的东西，事情会变得复杂和难以理解。以Asp.net为例，它的定制特性可以使得只要在方法前加上[ajax method]类似这样的标志就可以称为一个异步方法，相信这使得Asp.net的Ajax开发显得更加“高效”或者是“神秘”，而更多的事情则被封装了。同样记住一条，任何对服务器端的请求仅仅是返回纯文本，我们不一定要依赖于封装好的处理过程，而完全可以自己来实现。

　　观点四：学好JavaScript

　　在大多数人看来，JavaScript总不是那么一种正规的语言，随便copy一段就碰巧能运行，学过c之类的人，一看也能看懂，而且在浏览器中常常有脚本错误提示，所以潜意识觉得总不能付之以大任。事实上，要学好Ajax，这就完全是一种错误的看法。javascript作为一种脚本语言，其语法的确不是很严格，但并不妨碍其完成诸多复杂的任务，没有JavaScript，就没有Ajax。所以本人强烈建议，学Ajax前，一定要好好研究一番JavaScript，一般来讲，如果能顺利看懂prototype框架的代码（如：prototype-1.3.1.js），你的JavaScript水平就基本过关了。同时对DOM模型也可以算有一个基本的了解。

　　观点五：Ajax点缀：CSS

　　用JavaScript控制CSS其实很简单，基本上每个DOM对象都有一个style对象，只要把css属性里的”-”去掉，并让随后的字母变为大写就可以作为属性使用了，例如：element.style.backgroundColor=”#f00″;在css是：选择符 {background-color:#f00}

　　一口气说这么多，希望对大家有点用处。

基于JSON的高级AJAX开发技术

江小邪 — Sun, 25 Jul 2010 16:39:46 +0000

一、引言

　　毫无疑问，AJAX已经成为当今Web开发中一种强有力的用户交互技术，但是它的许多可能性应用仍然鲜为人知。在本文中，我们将来共同探讨如何使用JavaScript对象标志(JSON)和JSON分析器在服务器和客户端AJAX引擎之间创建复杂而强有力的JSON数据传输层。我们将详细讨论如何创建一组对象(在其它语言中经常被当作一个包)，如何把这些对象串行化为JSON以发送到服务器端，以及如何把服务器端JSON反串行化为客户端JavaScript对象。

　　提示：你可以在Douglas Crockford的网站上找到本文中使用的JSON分析器。

　　在继续阅读前，本文假定你已经掌握了JavaScript技术并且了解如何创建一个基本的AJAX引擎，并经由AJAX技术向服务器端发出请求和从服务器端接收响应。为了更好地理解本文中示例，你需要下载本文相应的源码文件。

　　二、开始

　　为了进一步抽象我们的AJAX请求并有助于我们以后在不同的应用程序间共享AJAX引擎代码，本文使用了一个我自己创建的AJAX引擎。为了使用这个引擎，我们简单地导入三个JavaScript文件并且向一个名为AjaxUpdater的对象发出请求。然后，由该引擎来负责处理其它任务，包括把响应代理到在该请求中指定的回调方法中。下面的示例展示了我们如何使用这个引擎发出请求以及导入相关的文件：

＜script type=”text/javascript”src=”javascript/model/Ajax.js”＞＜/script＞
＜script type=”text/javascript” src=”javascript/model/HTTP.js”＞＜/script＞
＜script type=”text/javascript” src=”javascript/model/AjaxUpdater.js”＞＜/script＞
＜script type=”text/javascript”＞
document.load = AjaxUpdater.Update(’GET’， URL， callback);
＜/script＞

　　首先，让我们来讨论JavaScript对象。

三、 JavaScript对象

　　JavaScript以前经常被误解，似乎它主要用于实现客户浏览器端图形效果。其实，JavaScript是一种强有力的语言，特别当它与AJAX以及一个应用程序的服务器端相结合时;但是，即使在客户端，JavaScript也能够实现远比你预料得多的多的功能。面向对象的JavaScript就是一个示例，它能够使我们创建对象，扩展内在对象，甚至能够把我们的对象创建成包以达到更容易的管理之目的。

　　在本文示例中，我们将创建三个对象：Auto，Car和Wheel。其中，每一个都是简单的对象;在此，我们仅使用它们来展示如何创建一个基本包。

　　首先，Auto对象被声明为一个新的对象：

　　var Auto = new Object();

　　注意，这个Auto对象将用作Car对象的父类。因此，Car对象将成为Auto对象的一个属性，只不过它被分离到另一个文件中以更易于管理(这个概念经常被用于其它面向对象的语言中，但是在JavaScript中却并不经常提起它)。下面是这个Car对象相应的代码：

　　Auto.Car = new Object();
　　Auto.Car.color = “#fff”;
　　Auto.Car.setColor = function(_color)
　　{
　　Auto.Car.color = _color;
　　}
　　Auto.Car.setColor(“#333″);

　　如你所见，该Car对象是Auto对象的一个子对象—这分明是一种类对象层次结构。这个对象有一个名为color的属性和一个用于设置它的方法。在此，我们把color属性设置为灰色以覆盖掉缺省的白色。当在后面我们串行化该对象时请牢记住这个事实。

　　下一个对象，Wheel，是Car的一个子对象：

Auto.Car.Wheel = new Object();
Auto.Car.Wheel.color = “#000″;

　　在此，Wheel是一个基本对象，但是它展示了对象层次中的又一个层。这个对象有一个称为color的缺省值为黑色(“#000”)的属性。

　　下面，让我们来分析一下为什么这些对象如此重要以及我们是如何使用它们提供的简单的属性的。

四、把JavaScript对象串行化为JSON

　　借助于JSON分析器，我们可以很容易地把刚才创建的JavaScript对象串行化为JSON。首先，我们需要下载该分析器的一个副本，并且要把它添加到文档中。下面是我在本文示例中用于导入该脚本的相应的代码：

＜script type=”text/javascript” src=”javascript/utils/jsonparser.js”＞＜/script＞

　　我已经把该分析器添加到我的javascript目录，即一个称为utils的子目录下。

　　下面是最终的包括到其中用于导入适当的JavaScript文件的代码片断：

以下是引用片段：
＜script type=”text/javascript” src=”javascript/Auto.js”＞＜/script＞
＜script type=”text/javascript” src=”javascript/Car.js”＞＜/script＞
＜script type=”text/javascript” src=”javascript/Wheel.js”＞＜/script＞
＜script type=”text/javascript” src=”javascript/utils/jsonparser.js”＞＜/script＞
＜script type=”text/javascript” src=”javascript/model/Ajax.js”＞＜/script＞
＜script type=”text/javascript” src=”javascript/model/HTTP.js”＞＜/script＞
＜script type=”text/javascript” src=”javascript/model/AjaxUpdater.js”＞＜/script＞

　　在导入适当的文件后，我们可以通过把两个div元素和一个onload事件简单地添加到HTML文档中开始串行化。这两个div元素将分别拥有ID：body和loading。其中，这个loading标签将由AJAX引擎使用来指示进度情况，而body标签将用于显示消息。

＜div id=”loading”＞＜/div＞
＜div id=”body”＞＜/div＞

　　onload事件相应于body元素并且设置它的innerHTML属性为JavaScript对象(作为一个串行化的JSON字符串)。为了实现这一目的，我在Auto对象上使用了jsonparser.js文件内的toJSONString方法：

＜body onload=”document.getElementById(’body’).innerHTML = ’＜b＞Local objects serialized as JSON＜/b＞
Auto Object: ’+ Auto.toJSONString();”＞

　　这段代码使用了Auto对象及其所有的子对象，并且使用JSON分析器的toJSONString方法把它们串行化为一个JSON字符串。然后，该数据可以被用作服务器端的一种数据交换格式。

　　你可能还记得，在前面我们曾调用了一个称为setColor的方法来改变Car对象的颜色。当时，我使用它是因为我想向你展示串行化能够在运行时刻的任何点上实现，而且还为了反映出对象中最新的数据。

　　如果你仔细分析一下onload事件，你会注意到，Car和Wheel对象都包装在方括号内，这些方括号代表了父对象(即Auto)。这意味着，该串行化的JavaScript对象能够在运行时刻被发送到服务器端以存储最新的数据，并且也可以在应用程序启动时从服务器端进行接收以便从数据库中检索多数的当前数据。最精彩的部分在于，为了创建一种“无缝”的过程，所有与服务器之间实现的数据交换都可以使用JSON技术来实现。

　　下面，让我们来看一下相同的数据是如何从服务器端接收的，以及它们是如何被使用最新的数据(典型地，来源于一个数据库)串行化为客户端JavaScript对象的。

五、把JSON反串行化为客户端JavaScript对象

　　在本文中，我简单地把一个静态文件创建为JSON响应，但是在实际开发中，你可以把这些数据存储在一个数据库中并且使用一种服务器端语言返回它。基于这一能力，我们就可以轻松地创建一种强有力的数据交换过程!在前面，我们已经分析了这一串行化过程。凭基本的AJAX体验，你应该能够理解数据是如何被寄送到服务器端的。现在，让我们着手讨论反串行化的问题。首先来看一个针对本文示例提供的静态JSON文件。这个文件其实是我们在上一节中串行化的数据：

}}

　　作为一个请求JSON文件的示例，当我们点击下列链接时将请求这个串行化的Auto对象：

＜a href=”javascript:AjaxUpdater.Update(’GET’， ’json/data.js’， displayResponse);”＞Get remote JSON＜/a＞

　　一旦接收到响应消息，我们的称为displayResponse回调方法就会被激活，然后，我们就能够反串行化并开始使用这些对象：

＜script type=”text/javascript”＞
function displayResponse()
{
　if(Ajax.checkReadyState(’loading’) == “OK”)
　{
　　var Auto = Ajax.request.responseText.parseJSON();
　　document.getElementById(“body”).innerHTML += ”
＜b＞Remote JSON unserialized＜/b＞”;
　　document.getElementById(“body”).innerHTML += ”
Car color: “+Auto.Car.color;
　　document.getElementById(“body”).innerHTML += ”
Wheel color: “+Auto.Car.Wheel.color;
　}
}
＜/script＞

　　这是相当激动人心的一部分!一旦我们拥有了该responseText，我们就能够简单地使用JSON分析器中的parseJSON方法来从串行化的数据中重建我们的Auto对象。借助于这个新的Auto对象，我们就可以调用相应的子对象。这个特征允许我们在服务器和客户端来回发送对象—而不必进行大量的分析工作，然而在以前标准的XML响应情况下我们将却必须这样做。这样以来，我们就可以创建出能够基于AJAX技术来保留自身状态的客户端JavaScript对象

PHP安全之数据过滤

江小邪 — Sun, 25 Jul 2010 16:38:25 +0000

在指南的开始，我们说过数据过滤在任何语言、任何平台上都是WEB应用安全的基石。这包含检验输入到应用的数据以及从应用输出的数据，而一个好的软件设计可以帮助开发人员做到：

确保数据过滤无法被绕过，确保不合法的信息不会影响合法的信息，并且识别数据的来源。

关于如何确保数据过滤无法被绕过有各种各样的观点，而其中的两种观点比其他更加通用并可提供更高级别的保障。

调度方法

这种方法是用一个单一的 PHP 脚本调度（通过 URL）。其他任何操作在必要的时候使用include或require包含进来。这种方法一般需要每个 URL 都传递一个单独的GET变量用于调度。这个GET变量可以被认为是用来替代脚本名称的更加简化的设计。例如：

http://example.org/dispatch.php?task=print_formdispatch.php是唯一的根文件(Document root)。它可以让开发者做两件非常重要的事情：

在dispatch.php最开始实现一些全局的安全处理，并且确保这些处理不可以被绕过。

容易确定在必要的地方进行数据过滤，特别是一些特殊目的的控制流操作中。

看下面的例子以便进一步讨论dispatch.php脚本:

如果这是唯一的可公开访问到的 PHP 脚本，则可以确信的一点是这个程序的设计可以确保在最开始的全局安全处理无法被绕过。同时也让开发者容易看到特定任务的控制流程。例如，不需要浏览整个代码就可以容易的知道：当$form_valid为true时，end.inc是唯一显示给用户的；由于它在process.inc被包含之前，并刚刚初始化为false，可以确定的是process.inc的内部逻辑会将设置它为true；否则表单将再次显示（可能会显示相关的错误信息）。

注意

如果你使用目录定向文件，如index.php（代替dispatch.php），你可以像这样使用 URL 地址：http://example.org/?task=print_form。

你还可以使用 ApacheForceType重定向或者mod_rewrite来调整 URL 地址：http://example.org/app/print-form。

包含方法

另外一种方式是使用单独一个模块，这个模块负责所有的安全处理。这个模块被包含在所有公开的 PHP 脚本的最前端（或者非常靠前的部分）。参考下面的脚本security.inc

在本例中，每个提交过来的表单都认为应当含有form这个唯一验证值，并且security.inc独立处理表单中0需要过滤的数据。实现这个要求的 HTML 表单如下所示：

叫做$allowed的数组用来检验哪个表单变量是允许的，这个列表在表单被处理前应当是一致的。流程控制决定要执行什么，而process.inc是真正过滤后的数据到达的地方。

注意

确保security.inc总是被包含在每个脚本的最开始的位置比较好的方法是使用auto_prepend_file设置。

过滤的例子

建立白名单对于数据过滤是非常重要的。由于不可能对每一种可能遇到的表单数据都给出例子，部分例子可以帮助你对此有一个大体的了解。

下面的代码对邮件地址进行了验证：

]+@([-a-z0-9]+\.)+[a-z]{2,}$/i’;if (preg_match($email_pattern, $_POST['email'])){$clean['email'] = $_POST['email'];}?>下面的代码确保了$_POST['color']的内容是red，green，或者blue：

下面的代码确保$_POST['num']是一个整数（integer）：

下面的代码确保$_POST['num']是一个浮点数（float）：

名字转换
之前每个例子都使用了数组$clean。对于开发人员判断数据是否有潜在的威胁这是一个很好的习惯。永远不要在对数据验证后还将其保存在$_POST或者$_GET中，作为开发人员对超级全局数组中保存的数据总是应当保持充分的怀疑。

需要补充的是，使用$clean可以帮助思考还有什么没有被过滤，这更类似一个白名单的作用。可以提升安全的等级。

如果仅仅将验证过的数据保存在$clean，在数据验证上仅存的风险是你所引用的数组元素不存在，而不是未过滤的危险数据。

时机

一旦 PHP 脚本开始执行，则意味着 HTTP 请求已经全部结束。此时，用户便没有机会向脚本发送数据。因此，没有数据可以被输入到脚本中（甚至register_globals被开启的情况下）。这就是为什么初始化变量是非常好的习惯。

Rsync详解

江小邪 — Sat, 22 May 2010 21:38:09 +0000

1、什么是Rsync

Rsync（remote synchronize）是一个远程数据同步工具，可通过LAN/WAN快速同步多台主机间的文件。Rsync使用所谓的“Rsync算法”来使本地和远程两个主机之间的文件达到同步，这个算法只传送两个文件的不同部分，而不是每次都整份传送，因此速度相当快。

Rsync本来是用于替代rcp的一个工具，目前由rsync.samba.org维护，所以rsync.conf文件的格式类似于samba的主配置文件。Rsync可以通过rsh或ssh使用，也能以daemon模式去运行，在以daemon方式运行时Rsync server会打开一个873端口，等待客户端去连接。连接时，Rsync server会检查口令是否相符，若通过口令查核，则可以开始进行文件传输。第一次连通完成时，会把整份文件传输一次，以后则就只需进行增量备份。

Rsync支持大多数的类Unix系统，无论是Linux、Solaris还是BSD上都经过了良好的测试。此外，它在windows平台下也有相应的版本，如cwRsync和Sync2NAS等工具。

Rsync的基本特点如下：

1.可以镜像保存整个目录树和文件系统；

2.可以很容易做到保持原来文件的权限、时间、软硬链接等；

3.无须特殊权限即可安装；

4.优化的流程，文件传输效率高；

5.可以使用rsh、ssh等方式来传输文件，当然也可以通过直接的socket连接；

6.支持匿名传输。
2、Rsync同步算法

Rsync只所以同步文件的速度相当快，是因为“Rsync同步算法”能在很短的时间内计算出需要备份的数据，关于Rsync的同步算法描述如下：

假定在1号和2号两台计算机之间同步相似的文件A与B，其中1号对文件A拥有访问权，2号对文件B拥有访问权。并且假定主机1号与2号之间的网络带宽很小。那么rsync算法将通过下面的五个步骤来完成：

1、2号将文件B分割成一组不重叠的固定大小为S字节的数据块，最后一块可能会比S 小。
2、2号对每一个分割好的数据块执行两种校验：一种是32位的滚动弱校验，另一种是128位的MD4强校验。
3、2号将这些校验结果发给1号。
4、1号通过搜索文件A的所有大小为S的数据块(偏移量可以任选，不一定非要是S的倍数)，来寻找与文件B的某一块有着相同的弱校验码和强校验码的数据块。这项工作可以借助滚动校验的特性很快完成。
5、1号发给2号一串指令来生成文件A在2号上的备份。这里的每一条指令要么是对文件B经拥有某一个数据块而不须重传的证明，要么是一个数据块，这个数据块肯定是没有与文件B的任何一个数据块匹配上的。

3、Rsync参数说明
3.1 rsyncd.conf配置文件
－、全局参数

在文件中[module]之前的所有参数都是全局参数，当然也可以在全局参数部分定义模块参数，这时候该参数的值就是所有模块的默认值。

port

指定后台程序使用的端口号，默认为873。
motd file

“motd file”参数用来指定一个消息文件，当客户连接服务器时该文件的内容显示给客户，默认是没有motd文件的。
log file

“log file”指定rsync的日志文件，而不将日志发送给syslog。比如可指定为“/var/log/rsyncd.log”。
pid file

指定rsync的pid文件，通常指定为“/var/run/rsyncd.pid”。
syslog facility

指定rsync发送日志消息给syslog时的消息级别，常见的消息级别是：uth, authpriv, cron, daemon, ftp, kern, lpr, mail, news, security, sys-log, user, uucp, local0, local1, local2, local3,local4, local5, local6和local7。默认值是daemon。

二、模块参数

主要是定义服务器哪个目录要被同步。其格式必须为“[module]”形式，这个名字就是在rsync 客户端看到的名字，其实有点象Samba服务器提供的共享名。而服务器真正同步的数据是通过 path 来指定的。我们可以根据自己的需要，来指定多个模块，模块中可以定义以下参数：

comment

给模块指定一个描述，该描述连同模块名在客户连接得到模块列表时显示给客户。默认没有描述定义。
path

指定该模块的供备份的目录树路径，该参数是必须指定的。
use chroot

如果”use chroot”指定为true，那么rsync在传输文件以前首先chroot到path参数所指定的目录下。这样做的原因是实现额外的安全防护，但是缺点是需要以roots权限，并且不能备份指向外部的符号连接所指向的目录文件。默认情况下chroot值为true。
uid

该选项指定当该模块传输文件时守护进程应该具有的uid，配合gid选项使用可以确定哪些可以访问怎么样的文件权限，默认值是”nobody”。
gid

该选项指定当该模块传输文件时守护进程应该具有的gid。默认值为”nobody”。
max connections

指定该模块的最大并发连接数量以保护服务器，超过限制的连接请求将被告知随后再试。默认值是0，也就是没有限制。
list

该选项设定当客户请求可以使用的模块列表时，该模块是否应该被列出。如果设置该选项为false，可以创建隐藏的模块。默认值是true。
read only

该选项设定是否允许客户上载文件。如果为true那么任何上载请求都会失败，如果为false并且服务器目录读写权限允许那么上载是允许的。默认值为true。
exclude

用来指定多个由空格隔开的多个文件或目录(相对路径)，并将其添加到exclude列表中。这等同于在客户端命令中使用–exclude来指定模式，一个模块只能指定一个exclude选项。但是需要注意的一点是该选项有一定的安全性问题，客户很有可能绕过exclude列表，如果希望确保特定的文件不能被访问，那就最好结合uid/gid选项一起使用。
exclude from

指定一个包含exclude模式的定义的文件名，服务器从该文件中读取exclude列表定义。
include

用来指定不排除符合要求的文件或目录。这等同于在客户端命令中使用–include来指定模式，结合include和exclude可以定义复杂的exclude/include规则。
include from

指定一个包含include模式的定义的文件名，服务器从该文件中读取include列表定义。
auth users

该选项指定由空格或逗号分隔的用户名列表，只有这些用户才允许连接该模块。这里的用户和系统用户没有任何关系。如果”auth users”被设置，那么客户端发出对该模块的连接请求以后会被rsync请求challenged进行验证身份这里使用的challenge/response认证协议。用户的名和密码以明文方式存放在”secrets file”选项指定的文件中。默认情况下无需密码就可以连接模块(也就是匿名方式)。
secrets file

该选项指定一个包含定义用户名:密码对的文件。只有在”auth users”被定义时，该文件才有作用。文件每行包含一个username:passwd对。一般来说密码最好不要超过8个字符。没有默认的secures file名，需要限式指定一个(例如：/etc/rsyncd.passwd)。注意：该文件的权限一定要是600，否则客户端将不能连接服务器。
strict modes

该选项指定是否监测密码文件的权限，如果该选项值为true那么密码文件只能被rsync服务器运行身份的用户访问，其他任何用户不可以访问该文件。默认值为true。
hosts allow

该选项指定哪些IP的客户允许连接该模块。客户模式定义可以是以下形式：

单个IP地址，例如：192.167.0.1
整个网段，例如：192.168.0.0/24，也可以是192.168.0.0/255.255.255.0

多个IP或网段需要用空格隔开，“*”则表示所有，默认是允许所有主机连接。
hosts deny

指定不允许连接rsync服务器的机器，可以使用hosts allow的定义方式来进行定义。默认是没有hosts deny定义。
ignore errors

指定rsyncd在判断是否运行传输时的删除操作时忽略server上的IO错误，一般来说rsync在出现IO错误时将将跳过–delete操作，以防止因为暂时的资源不足或其它IO错误导致的严重问题。
ignore nonreadable

指定rysnc服务器完全忽略那些用户没有访问权限的文件。这对于在需要备份的目录中有些文件是不应该被备份者得到的情况是有意义的。
lock file

指定支持max connections参数的锁文件，默认值是/var/run/rsyncd.lock。
transfer logging

使rsync服务器使用ftp格式的文件来记录下载和上载操作在自己单独的日志中。
log format

通过该选项用户在使用transfer logging可以自己定制日志文件的字段。其格式是一个包含格式定义符的字符串，可以使用的格式定义符如下所示：

%h 远程主机名

%a 远程IP地址

%l 文件长度字符数

%p 该次rsync会话的进程id

%o 操作类型：”send”或”recv”

%f 文件名

%P 模块路径

%m 模块名

%t 当前时间

%u 认证的用户名(匿名时是null)

%b 实际传输的字节数

%c 当发送文件时，该字段记录该文件的校验码

默认log格式为：”%o %h [%a] %m (%u) %f %l”，一般来说,在每行的头上会添加”%t [%p] “。在源代码中同时发布有一个叫rsyncstats的perl脚本程序来统计这种格式的日志文件。
timeout

通过该选项可以覆盖客户指定的IP超时时间。通过该选项可以确保rsync服务器不会永远等待一个崩溃的客户端。超时单位为秒钟，0表示没有超时定义，这也是默认值。对于匿名rsync服务器来说，一个理想的数字是600。
refuse options

通过该选项可以定义一些不允许客户对该模块使用的命令参数列表。这里必须使用命令全名，而不能是简称。但发生拒绝某个命令的情况时服务器将报告错误信息然后退出。如果要防止使用压缩，应该是：”dont compress = *”。
dont compress

用来指定那些不进行压缩处理再传输的文件，默认值是*.gz *.tgz *.zip *.z *.rpm *.deb *.iso *.bz2 *.tbz

3.2 Rsync命令

在对rsync服务器配置结束以后，下一步就需要在客户端发出rsync命令来实现将服务器端的文件备份到客户端来。rsync是一个功能非常强大的工具，其命令也有很多功能特色选项，我们下面就对它的选项一一进行分析说明。

Rsync的命令格式可以为以下六种：
rsync [OPTION]… SRC DEST

rsync [OPTION]… SRC [USER@]HOST:DEST

rsync [OPTION]… [USER@]HOST:SRC DEST

rsync [OPTION]… [USER@]HOST::SRC DEST

rsync [OPTION]… SRC [USER@]HOST::DEST

rsync [OPTION]… rsync://[USER@]HOST[:PORT]/SRC [DEST]
对应于以上六种命令格式，rsync有六种不同的工作模式：

1)拷贝本地文件。当SRC和DES路径信息都不包含有单个冒号”:”分隔符时就启动这种工作模式。如：rsync -a /data /backup

2)使用一个远程shell程序(如rsh、ssh)来实现将本地机器的内容拷贝到远程机器。当DST路径地址包含单个冒号”:”分隔符时启动该模式。如：rsync -avz *.c foo:src

3)使用一个远程shell程序(如rsh、ssh)来实现将远程机器的内容拷贝到本地机器。当SRC地址路径包含单个冒号”:”分隔符时启动该模式。如：rsync -avz foo:src/bar /data

4)从远程rsync服务器中拷贝文件到本地机。当SRC路径信息包含”::”分隔符时启动该模式。如：rsync -av root@172.16.78.192::www /databack

5)从本地机器拷贝文件到远程rsync服务器中。当DST路径信息包含”::”分隔符时启动该模式。如：rsync -av /databack root@172.16.78.192::www

6)列远程机的文件列表。这类似于rsync传输，不过只要在命令中省略掉本地机信息即可。如：rsync -v rsync://172.16.78.192/www
rsync参数的具体解释如下：
-v, –verbose 详细模式输出
-q, –quiet 精简输出模式
-c, –checksum 打开校验开关，强制对文件传输进行校验
-a, –archive 归档模式，表示以递归方式传输文件，并保持所有文件属性，等于-rlptgoD
-r, –recursive 对子目录以递归模式处理
-R, –relative 使用相对路径信息
-b, –backup 创建备份，也就是对于目的已经存在有同样的文件名时，将老的文件重新命名为~filename。可以使用–suffix选项来指定不同的备份文件前缀。
–backup-dir 将备份文件(如~filename)存放在在目录下。
-suffix=SUFFIX 定义备份文件前缀
-u, –update 仅仅进行更新，也就是跳过所有已经存在于DST，并且文件时间晚于要备份的文件。(不覆盖更新的文件)
-l, –links 保留软链结
-L, –copy-links 想对待常规文件一样处理软链结
–copy-unsafe-links 仅仅拷贝指向SRC路径目录树以外的链结
–safe-links 忽略指向SRC路径目录树以外的链结
-H, –hard-links 保留硬链结
-p, –perms 保持文件权限
-o, –owner 保持文件属主信息
-g, –group 保持文件属组信息
-D, –devices 保持设备文件信息
-t, –times 保持文件时间信息
-S, –sparse 对稀疏文件进行特殊处理以节省DST的空间
-n, –dry-run现实哪些文件将被传输
-W, –whole-file 拷贝文件，不进行增量检测
-x, –one-file-system 不要跨越文件系统边界
-B, –block-size=SIZE 检验算法使用的块尺寸，默认是700字节
-e, –rsh=COMMAND 指定使用rsh、ssh方式进行数据同步
–rsync-path=PATH 指定远程服务器上的rsync命令所在路径信息
-C, –cvs-exclude 使用和CVS一样的方法自动忽略文件，用来排除那些不希望传输的文件
–existing 仅仅更新那些已经存在于DST的文件，而不备份那些新创建的文件
–delete 删除那些DST中SRC没有的文件
–delete-excluded 同样删除接收端那些被该选项指定排除的文件
–delete-after 传输结束以后再删除
–ignore-errors 及时出现IO错误也进行删除
–max-delete=NUM 最多删除NUM个文件
–partial 保留那些因故没有完全传输的文件，以是加快随后的再次传输
–force 强制删除目录，即使不为空
–numeric-ids 不将数字的用户和组ID匹配为用户名和组名
–timeout=TIME IP超时时间，单位为秒
-I, –ignore-times 不跳过那些有同样的时间和长度的文件
–size-only 当决定是否要备份文件时，仅仅察看文件大小而不考虑文件时间
–modify-window=NUM 决定文件是否时间相同时使用的时间戳窗口，默认为0
-T –temp-dir=DIR 在DIR中创建临时文件
–compare-dest=DIR 同样比较DIR中的文件来决定是否需要备份
-P 等同于 –partial
–progress 显示备份过程
-z, –compress 对备份的文件在传输时进行压缩处理
–exclude=PATTERN 指定排除不需要传输的文件模式
–include=PATTERN 指定不排除而需要传输的文件模式
–exclude-from=FILE 排除FILE中指定模式的文件
–include-from=FILE 不排除FILE指定模式匹配的文件
–version 打印版本信息
–address 绑定到特定的地址
–config=FILE 指定其他的配置文件，不使用默认的rsyncd.conf文件
–port=PORT 指定其他的rsync服务端口
–blocking-io 对远程shell使用阻塞IO
-stats 给出某些文件的传输状态
–progress 在传输时现实传输过程
–log-format=formAT 指定日志文件格式
–password-file=FILE 从FILE中得到密码
–bwlimit=KBPS 限制I/O带宽，KBytes per second
-h, –help 显示帮助信息

4、Rsync使用实例
4.1、SSH方式

1、首先在服务端启动ssh服务：
# service sshd start

启动 sshd： [确定]
2、使用rsync进行同步

接下来就可以在客户端使用rsync命令来备份服务端上的数据了，SSH方式是通过系统用户来进行备份的，如下：
# rsync -vzrtopg –progress -e ssh –delete work@172.16.78.192:/www/* /databack/experiment/rsync

work@172.16.78.192′s password:

receiving file list …

5 files to consider

test/

0 100% 0.00kB/s 527:35:41 (1, 20.0% of 5)

67 100% 65.43kB/s 0:00:00 (2, 40.0% of 5)

0 100% 0.00kB/s 527:35:41 (3, 60.0% of 5)

100663296 100% 42.22MB/s 0:00:02 (4, 80.0% of 5)

sent 96 bytes received 98190 bytes 11563.06 bytes/sec

total size is 100663363 speedup is 1024.19
上面的信息描述了整个的备份过程，以及总共备份数据的大小。
4.2 、后台服务方式

1、启动rsync服务

编辑/etc/xinetd.d/rsync文件，将其中的disable=yes改为disable=no，并重启xinetd服务，如下：
# vi /etc/xinetd.d/rsync

#default: off

# description: The rsync server is a good addition to an ftp server, as it \

# allows crc checksumming etc.

service rsync

{

disable = no

socket_type = stream

wait = no

user = root

server = /usr/bin/rsync

server_args = –daemon

log_on_failure += USERID

}

# /etc/init.d/xinetd restart

停止 xinetd： [确定]

启动 xinetd： [确定]
2、创建配置文件

默认安装好rsync程序后，并不会自动创建rsync的主配置文件，需要手工来创建，其主配置文件为“/etc/rsyncd.conf”，创建该文件并插入如下内容：
# vi /etc/rsyncd.conf

uid=root

gid=root

max connections=4

log file=/var/log/rsyncd.log

pid file=/var/run/rsyncd.pid

lock file=/var/run/rsyncd.lock

secrets file=/etc/rsyncd.passwd

hosts deny=172.16.78.0/22

[www]

comment= backup web

path=/www

read only = no

exclude=test

auth users=work
3、创建密码文件

采用这种方式不能使用系统用户对客户端进行认证，所以需要创建一个密码文件，其格式为“username:password”，用户名可以和密码可以随便定义，最好不要和系统帐户一致，同时要把创建的密码文件权限设置为600，这在前面的模块参数做了详细介绍。
# echo “work:abc123″ > /etc/rsyncd.passwd

# chmod 600 /etc/rsyncd.passwd
4、备份

完成以上工作，现在就可以对数据进行备份了，如下：
# rsync -avz –progress –delete work@172.16.78.192::www /databack/experiment/rsync

Password:

receiving file list …

6 files to consider

./ files…

0 100% 0.00kB/s 528:20:41 (1, 50.0% of 6)

67 100% 65.43kB/s 0:00:00 (2, 66.7% of 6)

0 100% 0.00kB/s 528:20:41 (3, 83.3% of 6)

100663296 100% 37.49MB/s 0:00:02 (4, 100.0% of 6)

sent 172 bytes received 98276 bytes 17899.64 bytes/sec

total size is 150995011 speedup is 1533.75
5、恢复

当服务器的数据出现问题时，那么这时就需要通过客户端的数据对服务端进行恢复，但前提是服务端允许客户端有写入权限，否则也不能在客户端直接对服务端进行恢复，使用rsync对数据进行恢复的方法如下：
# rsync -avz –progress /databack/experiment/rsync/ work@172.16.78.192::www

Password:

building file list …

6 files to consider

67 100% 0.00kB/s 0:00:00 (2, 66.7% of 6)

sent 258 bytes received 76 bytes 95.43 bytes/sec

total size is 150995011 speedup is 452080.87

5、示例脚本

这里这些脚本都是rsync网站上的例子：
1、每隔七天将数据往中心服务器做增量备份
#!/bin/sh
# This script does personal backups to a rsync backup server. You will end up
# with a 7 day rotating incremental backup. The incrementals will go
# into subdirectories named after the day of the week, and the current
# full backup goes into a directory called “current”
# tridge@linuxcare.com
# directory to backup
BDIR=/home/$USER
# excludes file – this contains a wildcard pattern per line of files to exclude
EXCLUDES=$HOME/cron/excludes
# the name of the backup machine
BSERVER=owl
# your password on the backup server
export RSYNC_PASSWORD=XXXXXX
########################################################################
BACKUPDIR=`date +%A`
OPTS=”–force –ignore-errors –delete-excluded –exclude-from=$EXCLUDES
–delete –backup –backup-dir=/$BACKUPDIR -a”
export PATH=$PATH:/bin:/usr/bin:/usr/local/bin
# the following line clears the last weeks incremental directory
[ -d $HOME/emptydir ] || mkdir $HOME/emptydir
rsync –delete -a $HOME/emptydir/ $BSERVER::$USER/$BACKUPDIR/
rmdir $HOME/emptydir
# now the actual transfer
rsync $OPTS $BDIR $BSERVER::$USER/current
2、备份至一个空闲的硬盘
#!/bin/sh
export PATH=/usr/local/bin:/usr/bin:/bin
LIST=”rootfs usr data data2″
for d in $LIST; do
mount /backup/$d
rsync -ax –exclude fstab –delete /$d/ /backup/$d/
umount /backup/$d
done
DAY=`date “+%A”`
rsync -a –delete /usr/local/apache /data2/backups/$DAY
rsync -a –delete /data/solid /data2/backups/$DAY
3、对vger.rutgers.edu的cvs树进行镜像
#!/bin/bash
cd /var/www/cvs/vger/
PATH=/usr/local/bin:/usr/freeware/bin:/usr/bin:/bin
RUN=`lps x | grep rsync | grep -v grep | wc -l`
if [ "$RUN" -gt 0 ]; then
echo already running
exit 1
fi
rsync -az vger.rutgers.edu::cvs/CVSROOT/ChangeLog $HOME/ChangeLog
sum1=`sum $HOME/ChangeLog`
sum2=`sum /var/www/cvs/vger/CVSROOT/ChangeLog`
if [ "$sum1" = "$sum2" ]; then
echo nothing to do
exit 0
fi
rsync -az –delete –force vger.rutgers.edu::cvs/ /var/www/cvs/vger/
exit 0
6、FAQ

Q：如何通过ssh进行rsync，而且无须输入密码？

A：可以通过以下几个步骤
1. 通过ssh-keygen在server A上建立SSH keys，不要指定密码，你会在~/.ssh下看到identity和identity.pub文件

2. 在server B上的home目录建立子目录.ssh

3. 将A的identity.pub拷贝到server B上

4. 将identity.pub加到~[user b]/.ssh/authorized_keys

5. 于是server A上的A用户，可通过下面命令以用户B ssh到server B上了

e.g. ssh -l userB serverB

这样就使server A上的用户A就可以ssh以用户B的身份无需密码登陆到server B上了。
Q：如何通过在不危害安全的情况下通过防火墙使用rsync?

A：解答如下：
这通常有两种情况，一种是服务器在防火墙内，一种是服务器在防火墙外。无论哪种情况，通常还是使用ssh，这时最好新建一个备份用户，并且配置sshd仅允许这个用户通过RSA认证方式进入。如果服务器在防火墙内，则最好限定客户端的IP地址，拒绝其它所有连接。如果客户机在防火墙内，则可以简单允许防火墙打开TCP端口22的ssh外发连接就ok了。
Q：我能将更改过或者删除的文件也备份上来吗？

A：当然可以：
你可以使用如：rsync -other -options -backupdir = ./backup-2000-2-13 …这样的命令来实现。

这样如果源文件:/path/to/some/file.c改变了，那么旧的文件就会被移到./backup-2000-2-13/path/to/some/file.c，

这里这个目录需要自己手工建立起来
Q：我需要在防火墙上开放哪些端口以适应rsync？

A：视情况而定
rsync可以直接通过873端口的tcp连接传文件，也可以通过22端口的ssh来进行文件传递，但你也可以通过下列命令改变它的端口：
rsync –port 8730 otherhost::

或者

rsync -e ‘ssh -p 2002′ otherhost:
Q：我如何通过rsync只复制目录结构，忽略掉文件呢？

A：rsync -av –include ‘*/’ –exclude ‘*’ source-dir dest-dir
Q：为什么我总会出现”Read-only file system”的错误呢？

A：看看是否忘了设”read only = no”了
Q：为什么我会出现‘@ERROR: invalid gid’的错误呢？

A：rsync使用时默认是用uid=nobody;gid=nobody来运行的，如果你的系统不存在nobody组的话，就会出现这样的错误，可以试试gid = nogroup或者其它
Q：绑定端口873失败是怎么回事？

A：如果你不是以root权限运行这一守护进程的话，因为1024端口以下是特权端口，会出现这样的错误。你可以用–port参数来改变。
Q：为什么我认证失败？

A：从你的命令行看来：
你用的是：
> bash$ rsync -a 144.16.251.213::test test

> Password:

> @ERROR: auth failed on module test

> I dont understand this. Can somebody explain as to how to acomplish this.

> All suggestions are welcome.

应该是没有以你的用户名登陆导致的问题，试试rsync -a max@144.16.251.213::test test

PHP封装常用Javascript为JS类以便快速调用

江小邪 — Sat, 22 May 2010 21:32:51 +0000

# $Id: js.class.php,v 0.1 p $

// 禁止直接访问该页面
if (basename($HTTP_SERVER_VARS['PHP_SELF']) == "js.class.php") {
header("HTTP/1.0 404 Not Found");
}

# Purpose 封装了一些常用的Javascript代码，以便在PHP中快速调用

class JS{
function JS(){}

     #返回上页
     # @param $step 返回的层数默认为1
     function Back($step = -1){
         $msg = "history.go(".$step.");";
         JS::_Write($msg);
         JS::FreeResource();
         exit;
     }

    # 弹出警告的窗口
    # @param $msg 警告信息
     function Alert($msg){
         $msg = "alert(\"".$msg."\");";
         JS::_Write($msg);
     }

    # 写js
    # @param $msg
     function _Write($msg) {
         echo "";
     }

     # 刷新当前页
     function Reload(){
         $msg = "location.reload();";
         JS::FreeResource();
         JS::_Write($msg);
         exit;
     }

     #刷新弹出父页
     function ReloadOpener(){
         $msg = "if (opener)     opener.location.reload();";
         JS::_Write($msg);
     }

     #跳转到url
     #@param $url 目标页
     function Goto($url){
         $msg = "location.href = ‘$url’;";
         JS::FreeResource();
         JS::_Write($msg);
         exit;
     }

     #关闭窗口
     function Close(){
         $msg = "window.close()";
         JS::FreeResource();
         JS::_Write($msg);
         exit;
     }

     #提交表单
     #@param $frm 表单名
     function Submit($frm){
         $msg = $frm.".submit();";
         JS::_Write($msg);
     }

    #关闭数据库连接
    function FreeResource(){
         // 数据库连接标志
         global $conn;
         if (is_resource($conn))
             @mysql_close($conn);
     }
}
?>

mysql优化及全文搜索

江小邪 — Sat, 22 May 2010 21:29:20 +0000

mysql my.cnf文件常见优化模块
[mysqld]
port = 3306
server-id = 1
socket = /tmp/mysql.sock

# 避免MySQL的外部锁定，减少出错几率增强稳定性。
skip-locking

# 禁止MySQL对外部连接进行DNS解析
skip-name-resolve

# 指定MySQL可能的连接数量
back_log = 256

# 使用查询缓冲
query_cache_size = 32M
query_cache_type= 1

# 指定用于索引的缓冲区大小对于内存在4GB左右的服务器该参数可设置为256M或384M key_reads / key_read_requests 至少是1:100，1:1000更好
key_buffer_size = 256M

# 允许的请求包大小
max_allowed_packet = 4M

# 缓存可重用的线程数
thread_cache = 256
thread_cache_size = 64

# 每个线程的栈大小
thread_stack = 256K

# 指定表高速缓存的大小对于有1G内存的机器，推荐值是128－256
table_cache = 256K

# 查询排序时所能使用的缓冲区大小每连接独占
sort_buffer_size = 6M

# 读查询操作所能使用的缓冲区大小每连接独占
read_buffer_size = 4M

# 联合查询操作所能使用的缓冲区大小每连接独占
join_buffer_size = 8M

#MyISAM表发生变化时重新排序所需的缓冲
myisam_sort_buffer_size = 64M

# 指定MySQL查询缓冲区的大小
query_cache_size = 64M

tmp_table_size = 256M

# 指定MySQL允许的最大连接进程数
max_connections = 768

max_connect_errors = 10000000

# 指定一个请求的最大连接时间
wait_timeout = 10

# 该参数取值为服务器逻辑CPU数量×2
thread_concurrency = 8

#记录慢查询,然后对慢查询一一优化
log-slow-queries = slow.log
long_query_time = 2
log-queries-not-using-indexes

#关闭不需要的表类型,如果你需要,就不要加上这个
skip-innodb
skip-bdb
#指定用于索引的缓冲区大小，增加它可得到更好的索引处理性能。对于内存在4GB左右的服务器该参数可设置为256M或384M。注意：该参数值设置的过大反而会是服务器整体效率降低！
key_buffer_size = 256M

MySQL server has gone away 的解决办法

有时候使用MySQL(和PHP搭配之最佳组合)命令行导入备份时会出现“MySQL(和PHP搭配之最佳组合) server has gone away”错误，这可能是因为其中一些insert语句的大小超出了MySQL(和PHP搭配之最佳组合)目前设置的缓冲区大小。

解决办法

1.使用php(做为现在的主流开发语言)myadmin 备份MySQL(和PHP搭配之最佳组合)的时候，只选择

数据:
完整插入
扩展插入

扩展插入不要勾选

2.使用 MySQL(和PHP搭配之最佳组合)dump 备份的时候不添加 –opt

这样就只会生成完整的insert语句，导入时候不会出错。

3.修改my.ini

打开my.ini 找到[MySQL(和PHP搭配之最佳组合)d]这一行，下面添加

[MySQL(和PHP搭配之最佳组合)d]

#扩大缓冲区
max_allowed_packet=32M
保存后，重启MySQL(和PHP搭配之最佳组合)

my.cnf配置(转)

mysqld程序–目录和文件
basedir = path 使用给定目录作为根目录(安装目录)。
character-sets-dir = path 给出存放着字符集的目录。
datadir = path 从给定目录读取数据库文件。
pid-file = filename 为mysqld程序指定一个存放进程ID的文件(仅适用于UNIX/Linux系统); Init-V脚本需要使用这个文件里的进程ID结束mysqld进程。
socket = filename 为MySQL客户程序与服务器之间的本地通信指定一个套接字文件(仅适用于UNIX/Linux系统; 默认设置一般
是/var/lib/mysql/mysql.sock文件)。
在Windows环境下，如果MySQL客户与服务器是通过命名管道进行通信的，–sock选项给出的将是该命名管道的名字(默认设置是MySQL)。 lower_case_table_name = 1/0 新目录和数据表的名字是否只允许使用小写字母; 这个选项在Windows环境下的默认设置是1(只允许使用小写字母)。
mysqld程序–语言设置
character-sets-server = name 新数据库或数据表的默认字符集。为了与MySQL的早期版本保持兼容，这个字符集也可以用–default-character-set选项给出; 但这个选项已经显得有点过时了。
collation-server = name 新数据库或数据表的默认排序方式。
lanuage = name 用指定的语言显示出错信息。
mysqld程序–通信、网络、信息安全
enable-named-pipes 允许Windows 2000/XP环境下的客户和服务器使用命名管道(named pipe)进行通信。这个命名管道的默认名字是MySQL，但可以用–socket选项来改变。
local-infile [=0] 允许/禁止使用LOAD DATA LOCAL语句来处理本地文件。
myisam-recover [=opt1, opt2, ...] 在启动时自动修复所有受损的MyISAM数据表。这个选项的可取值有4种:DEFAULT、BACKUP、QUICK和FORCE; 它们与myisamchk程序的同名选项作用相同。
old-passwords 使用MySQL 3.23和4.0版本中的老算法来加密mysql数据库里的密码(默认使用MySQL 4.1版本开始引入的新加密算法)。 port = n 为MySQL程序指定一个TCP/IP通信端口(通常是3306端口)。
safe-user-create 只有在mysql.user数据库表上拥有INSERT权限的用户才能使用GRANT命令; 这是一种双保险机制(此用户还必须具备GRANT权限才能执行GRANT命令)。
shared-memory 允许使用内存(shared memory)进行通信(仅适用于Windows)。
shared-memory-base-name = name 给共享内存块起一个名字(默认的名字是MySQL)。
skip-grant-tables 不使用mysql数据库里的信息来进行访问控制(警告:这将允许用户任何用户去修改任何数据库)。
skip-host-cache 不使用高速缓存区来存放主机名和IP地址的对应关系。
skip-name-resovle 不把IP地址解析为主机名; 与访问控制(mysql.user数据表)有关的检查全部通过IP地址行进。
skip-networking 只允许通过一个套接字文件(Unix/Linux系统)或通过命名管道(Windows系统)进行本地连接，不允许ICP/IP连接; 这提高了安全性，但阻断了来自网络的外部连接和所有的Java客户程序(Java客户即使在本地连接里也使用TCP/IP)。
user = name mysqld程序在启动后将在给定UNIX/Linux账户下执行; mysqld必须从root账户启动才能在启动后切换到另一个账户下执行;
mysqld_safe脚本将默认使用–user=mysql选项来启动mysqld程序。
mysqld程序–内存管理、优化、查询缓存区
bulk_insert_buffer_size = n 为一次插入多条新记录的INSERT命令分配的缓存区长度(默认设置是8M)。
key_buffer_size = n 用来存放索引区块的RMA值(默认设置是8M)。
join_buffer_size = n 在参加JOIN操作的数据列没有索引时为JOIN操作分配的缓存区长度(默认设置是128K)。
max_heap_table_size = n HEAP数据表的最大长度(默认设置是16M); 超过这个长度的HEAP数据表将被存入一个临时文件而不是驻留在内存里。
max_connections = n MySQL服务器同时处理的数据库连接的最大数量(默认设置是100)。
query_cache_limit = n 允许临时存放在查询缓存区里的查询结果的最大长度(默认设置是1M)。
query_cache_size = n 查询缓存区的最大长度(默认设置是0，不开辟查询缓存区)。
query_cache_type = 0/1/2 查询缓存区的工作模式:0, 禁用查询缓存区; 1，启用查询缓存区(默认设置); 2，”按需分配”模式，只响应SELECT SQL_CACHE命令。
read_buffer_size = n 为从数据表顺序读取数据的读操作保留的缓存区的长度(默认设置是128KB); 这个选项的设置值在必要时可以用SQL命令SET SESSION read_buffer_size = n命令加以改变。
read_rnd_buffer_size = n 类似于read_buffer_size选项，但针对的是按某种特定顺序(比如使用了ORDER BY子句的查询)输出的查询结果(默认设置是256K)。
sore_buffer = n 为排序操作分配的缓存区的长度(默认设置是2M); 如果这个缓存区太小，则必须创建一个临时文件来进行排序。
table_cache = n 同时打开的数据表的数量(默认设置是64)。
tmp_table_size = n 临时HEAP数据表的最大长度(默认设置是32M); 超过这个长度的临时数据表将被转换为MyISAM数据表并存入一个临时文件。
mysqld程序–日志
log [= file] 把所有的连接以及所有的SQL命令记入日志(通用查询日志); 如果没有给出file参数，MySQL将在数据库目录里创建一个hostname.log文件作为这种日志文件(hostname是服务器的主机名)。
log-slow-queries [= file] 把执行用时超过long_query_time变量值的查询命令记入日志(慢查询日志); 如果没有给出file参数，MySQL将在数据库目录里创建一个hostname-slow.log文件作为这种日志文件(hostname是服务器主机名)。
long_query_time = n 慢查询的执行用时上限(默认设置是10s)。
long_queries_not_using_indexs 把慢查询以及执行时没有使用索引的查询命令全都记入日志(其余同–log-slow-queries选项)。
log-bin [= filename] 把对数据进行修改的所有SQL命令(也就是INSERT、UPDATE和DELETE命令)以二进制格式记入日志(二进制变更日志，binary update log)。这种日志的文件名是filename.n或默认的hostname.n，其中n是一个6位数字的整数(日志文件按顺序编号)。
log-bin-index = filename 二进制日志功能的索引文件名。在默认情况下，这个索引文件与二进制日志文件的名字相同，但后缀名是.index而不是.nnnnnn。
max_binlog_size = n 二进制日志文件的最大长度(默认设置是1GB)。在前一个二进制日志文件里的信息量超过这个最大长度之前，MySQL服务器会自动提供一个新的二进制日志文件接续上。
binlog-do-db = dbname 只把给定数据库里的变化情况记入二进制日志文件，其他数据库里的变化情况不记载。如果需要记载多个数据库里的变化情况，就必须在配置文件使用多个本选项来设置，每个数据库一行。
binlog-ignore-db = dbname 不把给定数据库里的变化情况记入二进制日志文件。
sync_binlog = n 每经过n次日志写操作就把日志文件写入硬盘一次(对日志信息进行一次同步)。n=1是最安全的做法，但效率最低。默认设置是n=0，意思是由操作系统来负责二进制日志文件的同步工作。
log-update [= file] 记载出错情况的日志文件名(出错日志)。这种日志功能无法禁用。如果没有给出file参数，MySQL会使用hostname.err作为种日志文件的名字。
mysqld程序–镜像(主控镜像服务器)
server-id = n 给服务器分配一个独一无二的ID编号; n的取值范围是1~2的32次方启用二进制日志功能。
log-bin = name 启用二进制日志功能。这种日志的文件名是filename.n或默认的hostname.n，其中的n是一个6位数字的整数(日志文件顺序编号)。
binlog-do/ignore-db = dbname 只把给定数据库里的变化情况记入二进制日志文件/不把给定的数据库里的变化记入二进制日志文件。
mysqld程序–镜像(从属镜像服务器)
server-id = n 给服务器分配一个唯一的ID编号
log-slave-updates 启用从属服务器上的日志功能，使这台计算机可以用来构成一个镜像链(A->B->C)。
master-host = hostname 主控服务器的主机名或IP地址。如果从属服务器上存在mater.info文件(镜像关系定义文件)，它将忽略此选项。
master-user = replicusername 从属服务器用来连接主控服务器的用户名。如果从属服务器上存在mater.info文件，它将忽略此选项。
master-password = passwd 从属服务器用来连接主控服务器的密码。如果从属服务器上存在mater.info文件，它将忽略此选项。
master-port = n 从属服务器用来连接主控服务器的TCP/IP端口(默认设置是3306端口)。
master-connect-retry = n 如果与主控服务器的连接没有成功，则等待n秒(s)后再进行管理方式(默认设置是60s)。如果从属服务器存在mater.info文件，它将忽略此选项。
master-ssl-xxx = xxx 对主、从服务器之间的SSL通信进行配置。
read-only = 0/1 0: 允许从属服务器独立地执行SQL命令(默认设置); 1: 从属服务器只能执行来自主控服务器的SQL命令。
read-log-purge = 0/1 1: 把处理完的SQL命令立刻从中继日志文件里删除(默认设置); 0: 不把处理完的SQL命令立刻从中继日志文件里删除。
replicate-do-table = dbname.tablename 与–replicate-do-table选项的含义和用法相同，但数据库和数据库表名字里允许出现通配符”%” (例如: test%.%–对名字以”test”开头的所有数据库里的所以数据库表进行镜像处理)。
replicate-do-db = name 只对这个数据库进行镜像处理。
replicate-ignore-table = dbname.tablename 不对这个数据表进行镜像处理。
replicate-wild-ignore-table = dbn.tablen 不对这些数据表进行镜像处理。
replicate-ignore-db = dbname 不对这个数据库进行镜像处理。
replicate-rewrite-db = db1name > db2name 把主控数据库上的db1name数据库镜像处理为从属服务器上的db2name数据库。
report-host = hostname 从属服务器的主机名; 这项信息只与SHOW SLAVE HOSTS命令有关–主控服务器可以用这条命令生成一份从属服务器的名单。
slave-compressed-protocol = 1 主、从服务器使用压缩格式进行通信–如果它们都支持这么做的话。
slave-skip-errors = n1, n2, …或all 即使发生出错代码为n1、n2等的错误，镜像处理工作也继续进行(即不管发生什么错误，镜像处理工作也继续进行)。
如果配置得当，从属服务器不应该在执行SQL命令时发生错误(在主控服务器上执行出错的SQL命令不会被发送到从属服务器上做镜像处理); 如果不使用
slave-skip-errors选项，从属服务器上的镜像工作就可能国为发生错误而中断，中断后需要有人工参与才能继续进行。
mysqld–InnoDB–基本设置、表空间文件
skip-innodb 不加载InnoDB数据表驱动程序–如果用不着InnoDB数据表，可以用这个选项节省一些内存。
innodb-file-per-table 为每一个新数据表创建一个表空间文件而不是把数据表都集中保存在中央表空间里(后者是默认设置)。该选项始见于MySQL 4.1。
innodb-open-file = n InnoDB数据表驱动程序最多可以同时打开的文件数(默认设置是300)。如果使用了innodb-file-per-table选项并且需要同时打开很多数据表的话，这个数字很可能需要加大。
innodb_data_home_dir = p InnoDB主目录，所有与InnoDB数据表有关的目录或文件路径都相对于这个路径。在默认的情况下，这个主目录就是MySQL的数据目录。
innodb_data_file_path = ts 用来容纳InnoDB为数据表的表空间: 可能涉及一个以上的文件; 每一个表空间文件的最大长度都必须以字节(B)、兆字节(MB)或千兆字节(GB)为单位给出; 表空间文件的名字必须以分号隔开; 最后一个表空间文件还可以带一个autoextend属性和一个最大长度(max:n)。
例如，ibdata1:1G; ibdata2:1G:autoextend:max:2G的意思是: 表空间文件ibdata1的最大长度是1GB，ibdata2的最大长度也是1G，但允许它扩充到2GB。
除文件名外，还可以用硬盘分区的设置名来定义表空间，此时必须给表空间的最大初始长度值加上newraw关键字做后缀，给表空间的最大扩充长度值加上raw关键字做后缀(例如/dev/hdb1:20Gnewraw或/dev/hdb1:20Graw); MySQL 4.0及更高版本的默认设置是ibdata1:10M:autoextend。
innodb_autoextend_increment = n 带有autoextend属性的表空间文件每次加大多少兆字节(默认设置是8MB)。这个属性不涉及具体的数据表文件，那些文件的增大速度相对是比较小的。
innodb_lock_wait_timeout = n 如果某个事务在等待n秒(s)后还没有获得所需要的资源，就使用ROLLBACK命令放弃这个事务。这项设置对于发现和处理未能被InnoDB数据表驱动程序识别出来的死锁条件有着重要的意义。这个选项的默认设置是50s。
innodb_fast_shutdown 0/1 是否以最快的速度关闭InnoDB，默认设置是1，意思是不把缓存在INSERT缓存区的数据写入数据表，那些数据将在MySQL服务器下次启动时再写入(这么做没有什么风险，因为INSERT缓存区是表空间的一个组成部分，数据不会丢失)。把这个选项设置为0反面危险，因为在计算机关闭时，InnoDB驱动程序很可能没有足够的时间完成它的数据同步工作，操作系统也许会在它完成数据同步工作之前强行结束InnoDB，而这会导致数据不完整。
mysqld程序–InnoDB–日志
innodb_log_group_home_dir = p 用来存放InnoDB日志文件的目录路径(如ib_logfile0、ib_logfile1等)。在默认的情况下，InnoDB驱动程序将使用MySQL数据目录作为自己保存日志文件的位置。
innodb_log_files_in_group = n 使用多少个日志文件(默认设置是2)。InnoDB数据表驱动程序将以轮转方式依次填写这些文件; 当所有的日志文件都写满以后，之后的日志信息将写入第一个日志文件的最大长度(默认设置是5MB)。这个长度必须以MB(兆字节)或GB(千兆字节)为单位进行设置。
innodb_flush_log_at_trx_commit = 0/1/2 这个选项决定着什么时候把日志信息写入日志文件以及什么时候把这些文件物理地写(术语称为”同步”)到硬盘上。设置值0的意思是每隔一秒写一次日志并进行同步，这可以减少硬盘写操作次数，但可能造成数据丢失; 设置值1(设置设置)的意思是在每执行完一条COMMIT命令就写一次日志并进行同步，这可以防止数据丢失，但硬盘写操作可能会很频繁; 设置值2是一般折衷的办法，即每执行完一条COMMIT命令写一次日志，每隔一秒进行一次同步。
innodb_flush_method = x InnoDB日志文件的同步办法(仅适用于UNIX/Linux系统)。这个选项的可取值有两种: fdatasync，用fsync()函数进行同步; O_DSYNC，用O_SYNC()函数进行同步。
innodb_log_archive = 1 启用InnoDB驱动程序的archive(档案)日志功能，把日志信息写入ib_arch_log_n文件。启用这种日志功能在InnoDB与MySQL一起使用时没有多大意义(启用MySQL服务器的二进制日志功能就足够用了)。
mysqld程序–InnoDB–缓存区的设置和优化
innodb_log_buffer_pool_size = n 为InnoDB数据表及其索引而保留的RAM内存量(默认设置是8MB)。这个参数对速度有着相当大的影响，如果计算机上只运行有MySQL/InnoDB数据库服务器，就应该把全部内存的80%用于这个用途。
innodb_log_buffer_size = n 事务日志文件写操作缓存区的最大长度(默认设置是1MB)。
innodb_additional_men_pool_size = n 为用于内部管理的各种数据结构分配的缓存区最大长度(默认设置是1MB)。
innodb_file_io_threads = n I/O操作(硬盘写操作)的最大线程个数(默认设置是4)。
innodb_thread_concurrency = n InnoDB驱动程序能够同时使用的最大线程个数(默认设置是8)。
mysqld程序–其它选项

bind-address = ipaddr MySQL服务器的IP地址。如果MySQL服务器所在的计算机有多个IP地址，这个选项将非常重要。
default-storage-engine = type 新数据表的默认数据表类型(默认设置是MyISAM)。这项设置还可以通过–default-table-type选项来设置。
default-timezone = name 为MySQL服务器设置一个地理时区(如果它与本地计算机的地理时区不一样)。
ft_min_word_len = n 全文索引的最小单词长度工。这个选项的默认设置是4，意思是在创建全文索引时不考虑那些由3个或更少的字符构建单词。
Max-allowed-packet = n 客户与服务器之间交换的数据包的最大长度，这个数字至少应该大于客户程序将要处理的最大BLOB块的长度。这个选项的默认设置是1MB。
Sql-mode = model1, mode2, … MySQL将运行在哪一种SQL模式下。这个选项的作用是让MySQL与其他的数据库系统保持最大程度的兼容。这个选项的可取值包括ansi、db2、oracle、no_zero_date、pipes_as_concat。
注意：如果在配置文件里给出的某个选项是mysqld无法识别的(如，因为犯了一个愚蠢的打字错误)，MySQL服务器将不启动。

MySQL的系统变量以调优性能

(1)、back_log：
要求 MySQL 能有的连接数量。当主要MySQL线程在一个很短时间内得到非常多的连接请求，这就起作用，然后主线程花些时间(尽管很短)检查连接并且启动一个新线程。
back_log值指出在MySQL暂时停止回答新请求之前的短时间内多少个请求可以被存在堆栈中。只有如果期望在一个短时间内有很多连接，你需要增加它，换句话说，这值对到来的TCP/IP连接的侦听队列的大小。你的操作系统在这个队列大小上有它自己的限制。试图设定back_log高于你的操作系统的限制将是无效的。
当你观察你的主机进程列表，发现大量 264084 | unauthenticated user | xxx.xxx.xxx.xxx | NULL | Connect | NULL | login | NULL 的待连接进程时，就要加大 back_log 的值了。默认数值是50，我把它改为500。

(2)、interactive_timeout：
服务器在关闭它前在一个交互连接上等待行动的秒数。一个交互的客户被定义为对 mysql_real_connect()使用 CLIENT_INTERACTIVE 选项的客户。默认数值是28800，我把它改为7200。

(3)、key_buffer_size：
索引块是缓冲的并且被所有的线程共享。key_buffer_size是用于索引块的缓冲区大小，增加它可得到更好处理的索引(对所有读和多重写)，到你能负担得起那样多。如果你使它太大，系统将开始换页并且真的变慢了。默认数值是8388600(8M)，我的MySQL主机有2GB内存，所以我把它改为 402649088(400MB)。

(4)、max_connections：
允许的同时客户的数量。增加该值增加 mysqld 要求的文件描述符的数量。这个数字应该增加，否则，你将经常看到 Too many connections 错误。默认数值是100，我把它改为1024 。

(5)、record_buffer：
每个进行一个顺序扫描的线程为其扫描的每张表分配这个大小的一个缓冲区。如果你做很多顺序扫描，你可能想要增加该值。默认数值是131072(128K)，我把它改为16773120 (16M)

(6)、sort_buffer：
每个需要进行排序的线程分配该大小的一个缓冲区。增加这值加速ORDER BY或GROUP BY操作。默认数值是2097144(2M)，我把它改为 16777208 (16M)。

(7)、table_cache：
为所有线程打开表的数量。增加该值能增加mysqld要求的文件描述符的数量。MySQL对每个唯一打开的表需要2个文件描述符。默认数值是64，我把它改为512。

(8)、thread_cache_size：
可以复用的保存在中的线程的数量。如果有，新的线程从缓存中取得，当断开连接的时候如果有空间，客户的线置在缓存中。如果有很多新的线程，为了提高性能可以这个变量值。通过比较 Connections 和 Threads_created 状态的变量，可以看到这个变量的作用。我把它设置为 80。

(10)、wait_timeout：
服务器在关闭它之前在一个连接上等待行动的秒数。默认数值是28800，我把它改为7200。

注：参数的调整可以通过修改 /etc/my.cnf 文件并重启 MySQL 实现。这是一个比较谨慎的工作，上面的结果也仅仅是我的一些看法，你可以根据你自己主机的硬件情况（特别是内存大小）进一步修改。

MySQL 的max_allowed_packet保护导致MySQL Server 不断的启停

那到底是什么原因造成MySQL死掉又启来呢？

如果MySQL能够正常自动启动，那访问这个页面对MySQL的影响是数据库系统可以自动识别出来的，出于一种自动保护的原因，它才会shutdown MySQL.

基于以上的原因，开始查找资料，看都有在哪些情况下MySQL会自动shutdown后又立即startup的。

首先想到的是buffer(read,sort,temp etc.)不足，那么修改配置文件，把它们都增大一倍后重启MySQL，还是同样的会死掉。

接下来想到的就是可能请求的连接包过大，检查配置文件，其中并没有max_allowed_packet声明。在配置文件中，设置max_allowed_packet=2M后，重新启动MySQL，问题解决！

呵呵，看来mysql的配置文件中还有很多内容可挖的哟，以后得多多注意了。

图片轮换类，IE7、OP、FF、Chrome测试通过

江小邪 — Sat, 22 May 2010 21:22:44 +0000

<html>
<title>新闻图片轮换类title>

eAccelerator与memcache的区别与用途

江小邪 — Sat, 22 May 2010 21:18:41 +0000

eAccelerator和memcache，是目前较为主流的两个可使用在PHP之中的缓存加速工具．

eAccelerator专门为PHP开发，而memcache不仅仅用在PHP之中，其他所有的语言都可以使用．

　eAccelerator的主要功能：
1. 缓存PHP文件的执行代码：在被缓存的代码再次被调用时，将直接从内存读取，从而在很大程度了PHP运行的速度．
2. 提供了共享内存操作函数：用户可以将自己的常见非资源对像，保存到内存之中，并可以随时读取出来．

　memcache的主要功能：
　提供共享内存操作函数，可以保存和读取数据

　两者的共同点：
　共同点：都提供了共享内存操作函数，可以用来保存和读取自己的数据

　两者的区别：
　eAccelerator作为PHP的扩展库存在，那么仅在PHP运行时，可以操作和读写共享内存，一般情况，只能由操作共享内存的程序自己调用．
　同时，eAccelerator可以缓存PHP程序的执行代码，提升程序的调入和执行速度．
　memcache主要作为一个共享内存服务器，其PHP扩展库仅仅作为PHP到memcache的连接库存在，类似MySQL扩展库．因而，memcache可以完全脱离PHP，其共享的数据，可以被不同的程序调用．

　根据两者的不同，我们将他们使用在真真需要的地方：
　eAccelerator主要用于单机PHP提速，缓存中间数据．对于实时性高，但数据操作量小的情况下，非常实用．
　memcache用于分布式或者集群系统，多台服务器可以共享数据．对于实时性高，同时数据操作量大的情况下，非常实用．

PHP中的Memcache函数库（Memcache Functions）

江小邪 — Sat, 22 May 2010 21:10:12 +0000

/usr/local/bin/memcached -d -m 10 -u root -l 127.0.0.1 -p 11211 -c 256 -P /tmp/memcached.pid
memcached 的服务正式启动

Memcache::add — 添加一个值，如果已经存在，则返回false
Memcache::addServer — 添加一个可供使用的服务器地址
Memcache::close — 关闭一个Memcache对象
Memcache::connect — 创建一个Memcache对象
memcache_debug — 控制调试功能
Memcache::decrement — 对保存的某个key中的值进行减法操作
Memcache::delete — 删除一个key值
Memcache::flush — 清除所有缓存的数据
Memcache::get — 获取一个key值
Memcache::getExtendedStats — 获取进程池中所有进程的运行系统统计
Memcache::getServerStatus — 获取运行服务器的参数
Memcache::getStats — 返回服务器的一些运行统计信息
Memcache::getVersion — 返回运行的Memcache的版本信息
Memcache::increment — 对保存的某个key中的值进行加法操作
Memcache::pconnect — 创建一个Memcache的持久连接对象
Memcache::replace — R对一个已有的key进行覆写操作
Memcache::set — 添加一个值，如果已经存在，则覆写
Memcache::setCompressThreshold — 对大于某一大小的数据进行压缩
Memcache::setServerParams — 在运行时修改服务器的参数

建议用面向对象的方式来测试这个库：

php
$memcache = new Memcache;
$memcache->connect(‘localhost‘, 11211) or die (“Could not connect“);
$version = $memcache->getVersion();
echo “Server’s version: “.$version.“
\n“;
?>

Memcache::getVersion方法的作用是返回运行的Memcache的版本信息。

Memcache::getStats方法的作用是返回服务器的一些运行统计信息。 Memcache::getStats方法有三个参数，第一个参数表示要求返回的类型：reset, malloc, maps, cachedump, slabs, items, sizes;第二个参数和第三个参数是在第一个参数设置为“cachedump”时使用的。Memcache::getExtendedStats方法的作用是获取进程池中所有进程的运行系统统计。

$memcache = new Memcache;
$memcache->connect(‘localhost‘, 11211) or die (“Could not connect“);
print_r($memcache->getStats());
/**
* Array
* (
* [pid] => 8052
* [uptime] => 9205
* [time] => 1205898428
* [version] => 1.2.5
* [pointer_size] => 32
* [rusage_user] => 0.008000
* [rusage_system] => 0.000000
* [curr_items] => 1
* [total_items] => 17
* [bytes] => 57
* [curr_connections] => 2
* [total_connections] => 15
* [connection_structures] => 3
* [cmd_get] => 9
* [cmd_set] => 23
* [get_hits] => 5
* [get_misses] => 4
* [evictions] => 0
* [bytes_read] => 671
* [bytes_written] => 850
* [limit_maxbytes] => 10485760
* [threads] => 1
* )
*/
?>

Memcache::connect方法的作用是创建一个Memcache对象。Memcache::pconnect方法的作用是创建一个Memcache的持久连接对象。 Memcache::close方法的作用是关闭一个Memcache对象。

Memcache::set方法的作用是添加一个值，Memcache::set方法有四个参数，第一个参数是key，第二个参数是value，第三个参数可选，表示是否压缩保存，第四个参数可选，用来设置一个过期自动销毁的时间。Memcache::add方法的作用和Memcache::set方法类似，区别是如果Memcache::add方法的返回值为false，表示这个key已经存在，而Memcache::set方法则会直接覆写。Memcache::get方法的作用是获取一个key 值，Memcache::get方法有一个参数，表示key。Memcache::replace方法的作用是对一个已有的key进行覆写操作，Memcache::replace方法有四个参数，作用和Memcache::set方法的相同。Memcache::delete方法的作用是删除一个key值，Memcache::delete方法有两个参数，第一个参数表示key，第二个参数可选，表示删除延迟的时间。

$memcache = new Memcache;
$memcache->connect(‘localhost‘, 11211) or die (“Could not connect“);
$memcache->set( ‘name‘, ‘leo‘, 0, 30);
if(!$memcache->add( ‘name‘, ‘susan‘, 0, 30))
{
echo ‘susan is exist‘;
};
$memcache->replace( ‘name‘, ‘lion‘, 0, 300);
echo $memcache->get( ‘name‘);
$memcache->delete( ‘name‘, 5);
?>

memcache_debug() 函数的作用是控制调试功能，前提是php在编译的时候使用了–enable-debug选项，否则这个函数不会有作用。

Memcache::addServer 方法的作用是添加一个可供使用的服务器地址，Memcache::addServer方法有8个参数，除了第一个参数意外，其他都是可选的，第一个参数表示服务器的地址，第二个参数表示端口，第三个参数表示是否是一个持久连接，第四个参数表示这台服务器在所有服务器中所占的权重，第五个参数表示连接的持续时间，第六个参数表示连接重试的间隔时间，默认为15,设置为-1表示不进行重试，第七个参数用来控制服务器的在线状态，第8个参数允许设置一个回掉函数来处理错误信息。
Memcache::setServerParams方法的作用是在运行时修改服务器的参数，Memcache::setServerParams方法有六个参数，Memcache::addServer方法少了第三和第四个参数。 Memcache::getServerStatus方法的作用是获取运行服务器的参数，两个参数分别表示的地址和端口。

function _callback_memcache_failure($host, $port) {
print “memcache ‘$host:$port‘ failed“;
}
$memcache = new Memcache;
$memcache->addServer(‘192.168.1.116‘, 11211);
$memcache->setServerParams(‘192.168.1.116‘, 11211, 1, 15, true, ‘_callback_memcache_failure‘);
echo $memcache->getServerStatus(‘192.168.1.116‘, 11211);
?>

Memcache::flush 方法的作用是清除所有缓存的数据，但是不会削去使用的内存空间。

Memcache::increment方法的作用是对保存的某个key中的值进行加法操作，Memcache::decremen方法的作用是对保存的某个key中的值进行减法操作。

$memcache = new Memcache;
$memcache->connect(‘localhost‘, 11211);
$memcache->set(‘test_item‘, 8);
$memcache->increment(‘test_item‘, 4);
echo $memcache->decrement(‘test_item‘, 7);
// 显示 5
?>

setCompressThreshold 方法的作用是对大于某一大小的数据进行压缩。setCompressThreshold方法有两个参数，第一个参数表示处理数据大小的临界点，第二个参数表示压缩的比例，默认为0.2。

$memcache = new Memcache;
$memcache->addServer(‘memcache_host‘, 11211);
$memcache->setCompressThreshold(20000, 0.2);
?>

用四叉树管理散布在平面上的对象

江小邪 — Fri, 17 Oct 2008 17:26:08 +0000

周末一直在考虑怎样在游戏服务器中保存和管理那些有平面坐标的对象。希望能方便的查到每个对象附近的东西。以往用过的方法是给（平面）场景打上格子，然后再把每个对象放入相应的格子中。

这次又遇到这个问题，却不想用网格的方法来解决问题了。

原因主要是这么几点：一，用网格对于大场景特别消耗内存，而且不太适合做无限延展的场景。二，查询每个对象周围的东西时，不太方便。格子的粒度越小，速度越慢。

虽然这两个问题，都可以通过改进算法来回避。不过这次，我想尝试一下用四叉树解决这个问题。

用四叉树的话，内存占用量应该 O(n) 。如果定死了四叉树的扩展深度，可以推算出节点的最大可能消耗量。我想，如果只是为了解决 AOI 的计算，5 级深度已经足够。这样，大约预分配出 20 * n 个节点，几乎肯定够用了。

我希望场景是从坐标原点向四周无限延展开，没有什么具体的尺寸限制。所以，这次实现的时候对四叉树做了改造。第一级的划分是一个特例，它将平面分成四块，每一块都可以向某个方向无限延伸。

接下来，把各种可供切割的平面分为 9 类：

2 6 1
7 5 9
3 8 4
我给这些类别编了号，5 号类型的平面有固定大小，可以被明确切割成四块，这四块依然是类型 5 。而类型 1 的块，被切割成四块后，四块的类型(按四个象限分布)分别是 1,6,5,9 。同理，类型 2,3,4 的平面，也会被切割成不同类型的四块。

类型 6,7,8,9 的平面由于他们只向一个方向延伸，所以只能被切割成 2 块，一块固定大小的正方型（类型 5），一块保留它原来的类型。

这样，我的数据结构不是一个完整的四叉树，有个支干上就只有两个分支了。如果一个对象被放到了离坐标原点过远的地方，树的深度可能很大（超过 5），但是宽度会减半。如果大多数对象都在原点附近的话，查找是很快的。

今天化了一通宵的时间来实现这个东西，写了四百多行 C 程序。因为要实际用到项目中去，效率上的考虑比较多，顾而时间用了近 8 个小时；而且篇幅也比我想象的长的多。

一般，我们会在四叉树的每个节点上保存父节点的指针。这样，遍历这棵树就不需要用递归实现。好久没有写纯算法的程序了，平时递归写惯了，今天为了实现个用回溯法遍历树的算法还颇费了点工夫。为了提高查找一个节点附近节点的效率，最后也做了特别的实现。

另外，因为树节点总数可以估算出来，我用了个预分配的大节点池，并内部实现了 gc 算法。这样，从四叉树上拿掉节点非常简单，分配新节点也很容易。事后想了一下，不用 gc 的话，用一个 freelist 来管理也慢不到哪去。

在四叉树的叶子上，存放一个对象链表即可。可以用一个备用链表，分配，释放，移动位置都不需要重新构造。估算了一下，对象在四叉树描述的场景中移动，处理过程应该是常数时间了。查询 AOI 区域的对象也是一个常数时间。总的来说，对今天的工作成果还是挺满意的

其实，通过动态增加层次来向边界延展的算法实现起来更简单，也没有增加太多储存和查询的负担。

数据服务器的设计

江小邪 — Fri, 17 Oct 2008 17:25:22 +0000

今天开始正式开始做数据服务器。在这点上，我希望一组服务器上所有的逻辑服务遇到的数据存取需求都通过一个单一的数据服务器完成。而且，写入数据是单向通讯的。即，逻辑服务器只提读写盘请求，而无须确认。写数据好说，读数据稍微难处理一点，我现在的方案是，数据服务器加载数据的部分只对位置服务器负责，把数据提交到位置服务器即可。位置服务器可以通过分析数据知道玩家的数据流应该流向哪台逻辑服务器。

以上逻辑是基于每个玩家有独立的数据的，而且一个玩家同时只存在于唯一一个场景。也就是说，当一组数据存活的时候，只唯一属于一台逻辑服务器。这样做的好处是，切换场景非常的简单，只是让玩家从一个场景退出，给数据服务器发出写盘指令，并发送所有数据。数据服务器写盘的同时也 cache 了这些数据，并向位置服务器提交新的位置，并把这些数据转发向位置服务器。位置服务器可以再转交给新的场景。

对于玩家登陆和登出的处理并没有特别之处，我们可以设立两个虚拟场景，一个负责登入，一个负责登出。每个新连接自动导入登入场景，这个场景负责发出加载指令（下面可以看到，甚至无须设置加载数据的协议）。然后再做一个自动的场景切换操作即可。而玩家登出，则是转入登出场景，这是一个黑洞，玩家的连接可以在这里安全的断掉。

当玩家不停的穿梭于各个场景之间时，为了避免频繁的数据转发，我们可以给玩家数据做一个赃标记。如果没有弄赃，实际的数据可以不被转发。这个标记的另一个意义在于，若数据没有弄赃，而数据服务器的 cache 中又没有数据时，就需要从外存加载了。其实这就是一个读请求。

月初我在公司内部讲解这个设计时，遭到了一些同事的疑问。最典型的一个是，帮派信息如何处理。的确，类似帮派的信息，不属于任何一个玩家。如果你单独设一个非玩家对象保存这些数据时，可能会分布到不同的逻辑服务器上。的确对数据服务器的设计是一个挑战。

今天仔细考虑过以后，我发现可以从设计上避免这个问题。方法如下：

以帮派为例，可以设一个帮派总坛的场景。这个场景可以是虚拟的，在 client 表现上甚至可以只有一个界面，进入这个场景的玩家之间可以相互不可见。这样减少了大量的通讯量。

玩家任何时候查询，修改，帮派数据的时候，都强制他进入这个场景工作（也就是独立进程维护唯一数据）。做完操作后，玩家可以从哪来的回哪去。表现上，他可能并不会察觉到自己进入了一个遥远的地方。

甚至很多玩法应蕴而生。比如帮派在各地开了分舵。组织要求你把总坛的物质运输到分舵。其实仓库里的数据都是放在一个进程中。表现上，玩家可能千里迢迢的押运货物，只是修改了一下物品的归属地而已。

帮派也可以开出空头支票，玩家接受支票交易时，或许要去帮派回所去查一下帮派的信誉度，或者验证一下支票能不能兑现。因为支票开出去到了玩家手上后，数据已经交给玩家个人管理，和帮派数据无关了。

这样，复制出来的帮派数据都有了时延，比如你不能及时得到帮主是谁，帮派里有什么变化等等。（只是举例，实际万一想解决，可以走聊天这种不可靠通道）但是我个人认为这是符合现实的。因为现实中要得知一件事情，也是依赖一个信息发生源的。

想通了这些后，个人感觉我们的设计最终还是保持了简洁。满符合 KISS 原则。每个进程好好干好一件事吧

ps. 这里也突出了心跳服务器的重要。许多虚拟场景，如帮派管理等，可以放慢它的心跳（至少不用处理战斗时 10Hz 那么高的频率），这样也降低了这些进程的负载。而玩家体验却并不会有太大的影响。

多进程的游戏服务器设计

江小邪 — Fri, 17 Oct 2008 17:24:20 +0000

目前，我们的游戏服务器组是按多进程的方式设计的。强调多进程，是想提另外一点，我们每个进程上是单线程的。所以，我们在设计中，系统的复杂点在于进程间如何交换数据；而不需要考虑线程间的数据锁问题。

如果肆意的做进程间通讯，在进程数量不断增加后，会使系统混乱不可控。经过分析后，我决定做如下的限制：

如果一个进程需要和多个服务器做双向通讯，那么这个进程不能处理复杂的逻辑，而只是过滤和转发数据用。即，这样的一个进程 S ，只会把进程 A 发过来的数据转发到 B ；或把进程 B 发过来的数据转发到 A 。或者从一端发过来的数据，经过简单的协议分析后，可以分发到不同的地方。例如，把客户端发过来的数据包中的聊天信息分离处理，交到聊天进程处理。

有逻辑处理的进程上的数据流一定是单向的，它可以从多个数据源读取数据，但是处理后一定反馈到另外的地方，而不需要和数据源做逻辑上的交互。

每个进程尽可能的保持单个输入点，或是单个输出点。

所有费时的操作均发到独立的进程，以队列方式处理。

按功能和场景划分进程，单一服务和单一场景中不再分离出多个进程做负载均衡。

性能问题上，我是这样考虑的：

我们应该充分利用多核的优势，这会是日后的发展方向。让每个进程要么处理大流量小计算量的工作；要么处理小流量大计算量的工作。这样多个进程放在一台物理机器上可以更加充分的利用机器的资源。

单线程多进程的设计，个人认为更能发挥多核的优势。这是因为没有了锁，每个线程都可以以最大吞吐量工作。增加的负担只是进程间的数据复制，在网游这种复杂逻辑的系统中，一般不会比逻辑计算更早成为瓶颈。如果担心，单线程没有利用多核计算的优势，不妨考虑以下的例子：

计算 a/b+c/d+e/f ，如果我们在一个进程中开三条线程利用三个核同时计算 a/b c/d e/f 固然不错，但它增加了程序设计的复杂度。而换个思路，做成三个进程，第一个只算 a/b 把结果交给第二个进程去算 c/d 于之的和，再交个第三个进程算 e/f 。对于单次运算来算，虽然成本增加了。它需要做额外的进程间通讯复制中间结果。但，如果我们有大量连续的这样的计算要做，整体的吞吐量却增加了。因为在算某次的 a/b 的时候，前一次的 c/d 可能在另一个核中并行计算着。

具体的设计中，我们只需要把处理数据包的任务切细，适当增加处理流水线的长度，就可以提高整个系统的吞吐量了。由于逻辑操作是单线程的，所以另需要注意的一点是，所有费时的操作都应该转发到独立的进程中异步完成。比如下面会提到的数据存取服务。

对于具体的场景管理是这样做的：

玩家连接进来后，所有数据包会经过一个叫做位置服务的进程中。这个进程可以区分玩家所在的位置，然后把玩家数据分发到对应的场景服务进程中。这个位置服务同时还管理玩家间消息的广播。即，单个的场景（逻辑）服务并不关心每个数据包为哪几个玩家所见，而由这个服务将其复制分发。

当玩家切换场景，场景服务器将玩家的数据发送给数据服务，数据服务进程 cache 玩家数据，并将数据写入数据库。然后把玩家的新的场景编号发回位置服务进程，这样位置服务器可以将后续的玩家数据包正确的转发到新的场景服务进程中。

掉落物品和资源生产同样可以统一管理，所以的场景（逻辑）进程都将生产新物件的请求发给物品分配服务，由物品分配服务生产出新物件后通知位置服务器产生新物品。

这样一系列的做法，最终保证了，每个场景服务器都有一个唯一的数据源——位置服务进程。它跟持久化在数据库中的数据无关，跟时钟也无关。由此带来的调试便利是很显著的。

最近，面临诸多进程的设计时，最先面临的一个复杂点在于启动阶段。显然，每个进程都配有一套配置文件指出其它进程的地址并不是一个好主意。而为每个服务都分配一个子域名在开发期也不太合适。结果我们采取了一个简单的方案：单独开发了一个名字服务器。它的功能类似 DNS ，但是可以让每个进程自由的注册自己的位置，还可以定期汇报自己的当前状态。这样，我们可以方便的用程序查询到需要的服务。名字服务器的协议用的类似 POP3 的文本协议，这让我们可以人手工 telnet 上去查阅。我相信以后我们的维护人员会喜欢这样的设计的。:D

无风的港湾 » 类

资深设计师Tony Ventrice解析手机游戏开发的四个层次

相关博文

odex相关知识

相关博文

ASP防注入新方式，希望对大家是有用的

相关博文

完美解决“由于这台计算机没有终端服务器客户端访问许可证”

相关博文

PHP和Socket简介

相关博文

php的文档句法(heredoc)

相关博文

PHP对文本数据库的基本操作方法

相关博文

require和include的异同

相关博文

AJAX的各种控件和类库

相关博文

基于JSON的高级AJAX开发技术

相关博文

PHP安全之数据过滤

相关博文

Rsync详解

相关博文

PHP封装常用Javascript为JS类以便快速调用

相关博文

mysql优化及全文搜索

相关博文

图片轮换类，IE7、OP、FF、Chrome测试通过

相关博文

eAccelerator与memcache的区别与用途

相关博文

PHP中的Memcache函数库（Memcache Functions）

相关博文

用四叉树管理散布在平面上的对象

相关博文

数据服务器的设计

相关博文

多进程的游戏服务器设计

相关博文