主要功能点

主动缓存，无异常情况下只从redis中取数据，不走mysql
列表的分类、排序
缓存数据中区分正在进行、未开始、已结束
分析sql语句触发redis缓存系统中数据的更新
对关联数据进行同步更新（例 广告中的数据里面有商品信息，当商品发生改变时，触发把广告中的相关商品数据内容也进行同步更新）
针对单个表的缓存数据重建功能

原理

列表分页及排序主要依赖于redis 的sort 命令，通过配置来触发是否启用，是否同步关联数据等

数据存储结构

用redis 的 set (集合) 来保存ID号索引
用redis 的 hash(哈希) 来保存内容数据。Data为json结构化内容数据，同时hash内存入其它元素保存排序用的排序字段和内容
例： hset(data, json_encode($data)) hset(price, 100) hset(sort, 1)

Key的组成

一个表中正在进行的主索引的key set结构 (taobao_item 表示数据表表名， cate 表示存储的是主索引)
redisCache:taobao_item:cate

未开始ID号索引Key set结构
redisCache:taobao_item: notstartids
已结束ID号索引 key set结构
redisCache:taobao_item:endids
正在进行的分类索引Key set结构 cate_id表示分类的字段，最后面的1表示分类号，一个分类一个索引
redisCache:taobao_item:cate:cate_id:1
正在进行的内容Key (hash结构) 222表示是内容的ID号
redisCache:taobao_item:content:222
未开始的内容Key (hash结构)
redisCache:taobao_item:notstart:22
已结束的内容Key (hash结构)
redisCache:taobao_item:end:22

排序命令

Sort redisCache:appmarket_app_commend:cate:cate_id:2

BY redisCache:appmarket_app_commend:content:*->sort:sort

GET redisCache:appmarket_app_commend:content:*->data

DESC

LIMIT 0 10

BY用于排序的Key，因为是hash结构，所以采用元素sort作为排序依据

GET 获取主内容，hash元素中的data 存储的是主内容的json结构化数据

LIMIT 分页，与mysql 的 limit作用方法一至

DESC 存在的话，为倒序，不存在的话为顺序

同步关联表数据

通过配置里的callback_sync_content 方法例如通过sql分析。监控到taobao_item发生update操作，因为设置了关联同步更新taobao_ad中的商品信息，所以触发，先从tabao_ad中通过回调配置中的get_id方法传入taoboa_item的主键ID号，得到tabao_ad中的主键ID，然后执行taobao_ad缓存的updateContent方法，从而实现关联更新taboa_ad中的相关数据

当数据过期时转存到已过期区域

基于用户触发
hash key也就是内容key会有一个过期时间，当内容key过期，但索引key中是没法设定过期的
当用户获取列表时，rediscache要对data进行处理(json_decode),同时，因为已过期的内容key不存在，通过sort命令获取的列表中存在false值，正常情况下是一个json结构化数据，
如果存在false值，触发转存动作，对索引key进行同样的sort，但不传get参数，得到ID号索引数据，从而对比得到需要删除的ID号，先删除正在进行中区域的索引数据
同时触发add动作，由rediscache再次存储数据，会自动根据源数据来进行入缓存作用

未开始数据转存正在进行中原理与正在进行的数据转存到已结束中

未开始的数据，添加时存入未开始内容key和未开始排序Key中，同时给未开始内容Key设定过期时间，也就是什么时候开始！
使用sort获取未开始列表的方法，因为未开始索引里的ID号是不会过期的，但内容有过期时间，所以一对比就知道哪个ID的数据由未开始转入已开始
在未开始索引key中删除，同时再次触发添加数据，由add方法自动判断数据存入的区域

支持多条件(AND)

因为每个条件都有一个索引key
分析多条件，得到多个索引key
使用sinterstore命令把多个索引key做交集并存入一个临时key中
使用这个临时索引key取列表数据命令原型 sinterstore key key1 key2 key3

缓存数据的重建

因为在rediscache中触发更新比较频繁，所以有可能会出现缓存数据与源数据不一致的情况
所以在管理后台做了缓存的重建功能
有待优化注意事项

数据重建时会自动加锁，防止多个操作，同时rediscache中这个表的缓存失效，自动从回调中的源数据中取数据
转存功能目前是基于用户触发，以后可以做异步，减少中间过程，优化用户获取列表的速度
因为rediscache做主动缓存内存代价太高，同时为了更高的性能，所以希望在缓存系统中存在的数据都是有效数据，尽量把该下架的下架，该删除的删除 （下架和删除，数据都会在rediscache中清除）
Redis做持久化，避免redis挂掉的情况下，需要对全部的数据做重建

server
{
listen 80;
server_name ye55.dev;
index index.html index.htm index.php default.html default.htm default.php;
root /home/www/ye55/trunk/www/;

if (!-f $request_filename) {
rewrite ^/(.*)$ /index.php/$1 last;
}
location ~ .*\.php(.*)$
{
fastcgi_pass unix:/tmp/php-cgi.sock;
fastcgi_index index.php;
include fcgi.conf;
fastcgi_split_path_info ^(.+\.php)(.*)$;
include fastcgi_params;
fastcgi_param PATH_INFO $fastcgi_path_info;
}
}

加上最近在看redis方面的资料，从头系统过了一遍redis,所以有了改进以前做的主动列表缓存的冲动，计划首先用在现在公司的一个新项目上，如果可行，就可以继续部署到老项目，改进性能。

要实现主动缓存，主要的问题在于以下几点

1. 怎么触发更新、删除、插入数据库时，同步更新redis里的数据

2. redis中数据的存储采用怎么的方式

3. 主动缓存中怎么排序和分类

4. redis意外停止服务的情况下，如果正常提供列表服务

5. 列表缓存应该工作在哪一层，dao ? service ?

6. redis中单个数据失效的情况下怎么剔除

7. 如果减少网络请求，尽量少的命令获取一个分布的数据

目前方案正在设想中，先写下些东西，做下记录，后面再逐步完善！

一，解决mysql数据改变时触发实时更新redis数据，并最少改动现有代码

所以想在加一层 cache 层，使用cache层可以在Controller和service二个层中相互调用。cache中的数据可以来源于dao也可以来源于service层

解决第一个问题，我的想法是，直接在sql执行时，获得sql语句分析sql , 决定是否更新redis中的数据。

二， 做要实现redis主动缓存的相关配置，配置如下

<?php

return array(
			// db_user 表做数据缓存
			'db_user' => array(
							// 定义分类的字段，用于生成多个id索引set
							'cate' => array('group_id', 'vip'),
							// 设定排序所要用到的字段，数字
							'sort' => array('sort', 'create_time', 'last_time', 'login_num'),
							'callback' => array(
												'get' => array('common::getUserService()', 'getOne'), //回调类与方法，用于更新单个数据
												//用于当redis数据丢失的情况从mysql中还原数据，需要用于反射来注入数据，有待完善
												'getlist' => array('common::getUserService()', 'getList'),
											), 

						),
		);

主要的意义在配置中告诉程序怎么输出，如果redis失效的情况下，绕过redis缓存系统，直接按回调中的方法从mysql中输出数据。

redis怎么存储缓存数据：

1. 用一个或多个sets 存 id号索引数据。 比如配置中cate字段没有设置，就类型 listcache:db_user:ids

如果配置了cate字段 则出现一组 listcache:db_user:ids:cate:group_id:1 sets来分别存放对应的ID号

2. 另使用一个hash来存储内容，结构因sort配置而变
hset list:cache:db_user:content:id:1 sort 1
hset list:cache:db_user:content:id:1 create_time 122323123
hset list:cache:db_user:content:id:1 last_time 1223231223
hset list:cache:db_user:content:id:1 login_num 20
hset list:cache:db_user:content:id:1 data 用户数据的序列化数据
上面非data用于排序使用

最后获取列表使用 sort 命令
例 sort list:cache:ids BY list:cache:db_user:content:id:*->sort DESC LIMIT 0 10
上面命令用于获取排过序id号数据
也可以直接获取最终的data数据 sort list:cache:ids BY list:cache:db_user:content:id:*->sort GET list:cache:db_user:content:id:*->data DESC LIMIT 0 10

就写到这吧，写得比较混乱。以后再整理些图出来，比较直观！

以前写的框架中路由功能非常有限，只是实现controller与action的选择，代码很简陋，没做过滤，安全性也有问题，所以就重写了一个路由。

框架出错提示

主要功能：

1. controller与action的选择
2. php正则rewrite美化url
3. 参数过滤
4. PATH_INFO与REQUEST_URI自动选择

代码如下

class router {

	static public $controller = '';
	static public $action     = '';
	static public $params     = array();

	static public function get() {
		$config = array(
						'controller_default'	=> 'index',
						'action_defalut'		=> 'index',
						'controller_delimiter'	=> '/',
						'action_delimiter'		=> '/',
						'params_delimiter'		=> '/',
						'params_kv_delimiter'	=> '/',
						'extension_default'		=> '.html',
					);
		if (false != $routerConfig = nash::config('main', 'router')) $config = array_merge($config, $routerConfig);

		//判断是否是GET形式
		if (isset($_GET['c']) || isset($_GET['a'])) {
			self::$controller = isset($_GET['c']) ? self::_filter($_GET['c']) : $config['controller_default'];
			self::$action = isset($_GET['a']) ? self::_filter($_GET['a']) : $config['action_defalut'];
			foreach ($_GET as $key => $value) {
				if (!in_array($key, array('c', 'a'))) self::$params[$key] = self::_filter($value);
			}
			return self::_output();
		}

		$queryString = isset($_SERVER['PATH_INFO']) ? self::_pathInfo() : self::_scriptName();
		$queryString = str_replace($config['extension_default'], '', $queryString);

		/********配置文件有rewrte规则时，对url进行改写**********/
		if (isset($config['rewrite']) && is_array($config['rewrite'])) $queryString = self::_rewrite($queryString, $config['rewrite']);

		/*******获取取controller******/
		if (false === $pos = stripos($queryString, $config['controller_delimiter'])) {
			self::$controller = empty($queryString) ? $config['controller_default'] : self::_filter($queryString);
			self::$action = $config['action_defalut'];
			return self::_output();
		}
		self::$controller = self::_filter(substr($queryString, 0, $pos));
		$queryString = substr($queryString, $pos+1);

		/*******获取取action******/
		if (false === $pos = stripos($queryString, $config['action_delimiter'])) {
			self::$action = empty($queryString) ? $config['action_defalut'] : self::_filter($queryString);
			return self::_output();
		}
		self::$action = self::_filter(substr($queryString, 0, $pos));
		$queryString = substr($queryString, $pos+1);
		if (empty($queryString)) return self::_output();

		/*******获取取params参数******/
		if (false === $pos = stripos($queryString, $config['params_kv_delimiter'])) {
			return self::_output();
		}

		//当params_kv_delimiter与params_delimiter两个分界符相同时
		if ($config['params_kv_delimiter'] == $config['params_delimiter']) {
			$array = explode($config['params_delimiter'], $queryString);
			$count = count($array);
			for ($i = 0; $i < $count; $i++) {
				if ($i%2 == 0) {
					self::$params[$array[$i]] = isset($array[$i+1]) && !empty($array[$i+1]) ? self::_filter($array[$i+1]) : '';
				}
			}
			return self::_output();
		}

		//当params_kv_delimiter与params_delimiter两个分界符不同
		if (false === $pos = stripos($queryString, $config['params_delimiter'])) {
			$array = explode($config['params_kv_delimiter'], $queryString);
			!empty($array[1]) && self::$params[$array[0]] = self::_filter($array[1]);
			return self::_output();
		}
		$array = explode($config['params_delimiter'], $queryString);
		foreach ($array as $value) {
			if (!empty($value)) {
				$arrayTmp = explode($config['params_kv_delimiter'], $value);
				!empty($arrayTmp[1]) && self::$params[$arrayTmp[0]] = self::_filter($arrayTmp[1]);
			}
		}
		return self::_output();
	}

	/**
	 * php实现的正则rewrite url
	 */
	static private function _rewrite($string, $regular) {
		return preg_replace (array_keys($regular), array_values($regular), $string);
	}

	/**
	 * 对参数进行过滤，防止注入攻击
	 */
	static private function _filter($value) {
		return filter::vars($value, '#s_z');
	}

	static private function _pathInfo() {
		$queryString = $_SERVER['PATH_INFO'] == '/' ? $_SERVER['PATH_INFO'] = '' : $_SERVER['PATH_INFO'];
		substr($queryString, 0, 1) == '/' && $queryString = substr($queryString, 1);
		return $queryString;
	}

	static private function _scriptName() {
		return substr(str_replace($_SERVER['SCRIPT_NAME'], '',$_SERVER['REQUEST_URI']),1);
	} 

	static private function _output() {
		return array(self::$controller, self::$action, self::$params);
	}
}
//$config = array('rewrite' => array('/user\/login\/(.*)/' => "user/login/url_$1"));
//var_dump(router::get());

static public function mkdir($path) {
	if (!is_dir($path) && self::mkdir(dirname($path))) return mkdir($path);
	return true;
}

php实现效率有一定的缺失，如果要高效率，还是写扩展比较好
经测试，5个memcache，每个memcache生成200个虚拟节点，set加get1000次，采用一致性哈希分布效率比原生单台速度相差5倍，效率有待优化
实现过程：

1. memcache的配置 ip+端口+虚拟节点序列号 做hash,使用的是crc32,形成一个闭环。
2. 对要操作的key进行crc32
3. 二分法在虚拟节点环中查找最近的一个虚拟节点
4. 从虚拟节点中提取真实的memcache ip和端口，做单例连接

代码如下：

<?php
/**
 * 一致性哈希memcache分布式，采用的是虚拟节点的方式解决分布均匀性问题,查找节点采用二分法快速查找
 * the last known user to change this file in the repository  <$LastChangedBy: nash.xiong $>
 * @author nash.xiong <nash.xiong@gmail.com>
 * @copyright Copyright &copy; 2003-2012 phpd.cn
 * @license
 */
class memcacheHashMap {

	private $_node = array();
	private $_nodeData = array();
	private $_keyNode = 0;
	private $_memcache = null;

	//每个物理服务器生成虚拟节点个数 [注：节点数越多，cache分布的均匀性越好，同时set get操作时，也更耗资源，10台物理服务器，采用200较为合理]
	private $_virtualNodeNum = 200; 

	private function __construct() {
		/* 放入配置文件 */
		$config = array(
						'127.0.0.1:11211',
						'127.0.0.1:11212',
						'127.0.0.1:11213',
						'127.0.0.1:11214',
						'127.0.0.1:11215'
					);

		if (!$config) throw new Exception('Cache config NULL');
		foreach ($config as $key => $value) {
			for ($i = 0; $i < $this->_virtualNodeNum; $i++) {
				$this->_node[sprintf("%u", crc32($value . '_' . $i))] = $value . '_' . $i;
			}
		}
		ksort($this->_node);
	}

	private function __clone(){}

	/**
	 * 单例，保证只有一个实例
	 */
	static public function getInstance() {
		static $memcacheObj = null;
		if (!is_object($memcacheObj)) {
			$memcacheObj = new self();
		}
		return $memcacheObj;
	}

	/**
	 * 根据key做一致性hash后连接到一台物理memcache服务器
	 * @param string $key
	 */
	private function _connectMemcache($key) {
		$this->_nodeData = array_keys($this->_node);
		$this->_keyNode = sprintf("%u", crc32($key));
		$nodeKey = $this->_findServerNode();
		//如果超出环，从头再用二分法查找一个最近的，然后环的头尾做判断，取最接近的节点
		if ($this->_keyNode > end($this->_nodeData)) {
			$this->_keyNode -= end($this->_nodeData);
			$nodeKey2 = $this->_findServerNode();
			if (abs($nodeKey2 - $this->_keyNode) < abs($nodeKey - $this->_keyNode))  $nodeKey = $nodeKey2;
		}
		var_dump($this->_node[$nodeKey]);
		list($config, $num) = explode('_', $this->_node[$nodeKey]);
		if (!$config) throw new Exception('Cache config Error');
		if (!isset($this->_memcache[$config])) {
			$this->_memcache[$config] = new Memcache;
			list($host, $port) = explode(':', $config);
			$this->_memcache[$config]->connect($host, $port);
		}
		return $this->_memcache[$config];
	}

	/**
	 * 采用二分法从虚拟memcache节点中查找最近的节点
	 * @param unknown_type $m
	 * @param unknown_type $b
	 */
	private function _findServerNode($m = 0, $b = 0) {
	    $total = count($this->_nodeData);
	    if ($total != 0 && $b == 0) $b = $total - 1;
	    if ($m < $b){
	        $avg = intval(($m+$b) / 2);
	        if ($this->_nodeData[$avg] == $this->_keyNode) return $this->_nodeData[$avg];
	        elseif ($this->_keyNode < $this->_nodeData[$avg] && ($avg-1 >= 0)) return $this->_findServerNode($m, $avg-1);
	        else return $this->_findServerNode($avg+1, $b);
	    }
		if (abs($this->_nodeData[$b] - $this->_keyNode) < abs($this->_nodeData[$m] - $this->_keyNode))  return $this->_nodeData[$b];
		else return $this->_nodeData[$m];
	}

	public function set($key, $value, $expire = 0) {
		return $this->_connectMemcache($key)->set($key, json_encode($value), 0, $expire);
	}

	public function add($key, $value, $expire = 0) {
		return $this->_connectMemcache($key)->add($key, json_encode($value), 0, $expire);
	}

	public function get($key) {
		return json_decode($this->_connectMemcache($key)->get($key), true);
	}

	public function delete($key) {
		return $this->_connectMemcache($key)->delete($key);
	}

}

$runData['BEGIN_TIME'] = microtime(true);
//测试一万次set加get
for($i=0;$i<10000;$i++) {
	$key = md5(mt_rand());
	$b = memcacheHashMap::getInstance()->set($key, time(), 10);
}

var_dump(number_format(microtime(true) - $runData['BEGIN_TIME'],6));
$runData['BEGIN_TIME'] = microtime(true);
$m= new Memcache;
$m->connect('127.0.0.1', 11211);
for($i=0;$i<10000;$i++) {
	$key = md5(mt_rand());
	$b = $m->set($key, time(), 0, 10);
}
var_dump(number_format(microtime(true) - $runData['BEGIN_TIME'],6));
//测试结果，采用一致性哈希分布效率比原生单台速度相差5倍

感谢HaKeem的提醒，程序发现一个bug,以前的代码会发生无法解锁的问题，放出修正后的代码
如果是redis2.2以上版本可以在lock逻辑中加上watch命令，锁定单个key

	/**
	 * 加锁  【新的加锁算法，采用redis做锁，redis失效情况下，返回 变量redisErrReturn 设定的值】
	 * @param string $key 唯一标识
	 * @param int $expire
	 * @return
	 */
	public function lock($key, $expire = 5) {
		try {
			list($key, $lockIdKey) = $this->_getLockKey($key);
			//抢锁，第一个线程抢到，并把过期时间写入锁
			if (Common::getQueue()->setnx($key, Common::getTime() + $expire)) return true;
			//没有抢到锁的线程，判断锁是否异常死锁，如果锁没有过期，返回false
			if (Common::getQueue()->get($key)  > Common::getTime()) return false;
			//锁因异常死锁并过期的情况下，多个并发线程再次抢锁，getset命令到过期时间，如果未过期，表示锁已被其它线程抢得，返回false
			if (Common::getQueue()->getset($key, Common::getTime() + $expire) > Common::getTime()) return false;
			Common::getQueue()->set($lockIdKey, $this->_lockId);
			return true;
		} catch (RedisException $e) {
			// 当捕捉到redis异常时，锁中断，返回变量redisErrReturn
			$this->_lockStatus = false;
			return $this->redisErrReturn;
		}
	}

	/**
	 * 给锁进行续期，延长锁的生效周期
	 * @param string $key
	 * @param int $expire       延时锁失效的秒数
	 * @param int $triggerTime  触发续期倒计时间
	 * @return
	 */
	public function updateExpire($key, $expire = 3, $triggerTime = 2) {
		if (!$this->_lockStatus) return true; //当redis失效，中断锁
		list($key, $lockIdKey) = $this->_getLockKey($key);
		$lockId = Common::getQueue()->get($lockIdKey);
		if ($this->_lockId === null || $lockId != $this->_lockId) return false;
		$time = Common::getQueue()->get($key);
		if ($time - $triggerTime <= Common::getTime()) return Common::getQueue()->set($key, $time + $expire);
	}

	/**
	 * 解锁
	 * @param string $key
	 * @return
	 */
	public function unlock($key) {
		if (!$this->_lockStatus) return true; //当redis失效，中断解锁
		list($key, $lockIdKey) = $this->_getLockKey($key);
		$lockId = Common::getQueue()->get($lockIdKey);
		if ($this->_lockId === null || $lockId != $this->_lockId) return false;
		Common::getQueue()->del($key);
		Common::getQueue()->del($lockIdKey);
		return true;
	}

	/**
	 * 清除死锁产生的无用key 默认清除24小时以前的无用key
	 * @param int $cleanTime  默认24小时
	 */
	public function cleanLockKey($cleanTime = 86400) {
		if ($cleanTime < 3600 || !$keys = Common::getQueue()->keys('PwLock:*')) return false;
		$i = 0;
		foreach ($keys as $value) {
			list($time, $lockId) = explode('|', Common::getQueue()->get($value));
			if (Common::getTime() - $time > $cleanTime) {
				if (Common::getQueue()->del($value)) $i++;
			}
		}
		return $i;
	}

	private function _getLockKey($key) {
		return array('PwLock:' . $key, 'PwLock:' . $key . ':lockId');
	}

mysql编译安装:

1. 建立mysql数据存储目录, 权限设置为mac os默认存在的_mysql权限：

mkdir -p /var/mysql/data/
chown -R _mysql:_mysql /var/mysql/

2. 下载mysql， 我下的版本为mysql-5.5.18， 执行以下跨平台编译命令：

cmake -DCMAKE_INSTALL_PREFIX=/usr/local/server/mysql -DMYSQL_DATADIR=/var/mysql/data -DWITH_INNOBASE_STORAGE_ENGINE=1 -DWITH_MEMORY_STORAGE_ENGINE=1 -DWITH_MYISAM_STORAGE_ENGINE=1 -DSYSCONFDIR=/etc/ -DWITH_SSL=yes -DDEFAULT_CHARSET=utf8 -DDEFAULT_COLLATION=utf8_general_ci -DWITH_READLINE=on

3. 编译， 安装：

make
sudo make install

4. 改变mysql目录的权限：

sudo chmod +w /usr/local/server/mysql
sudo chown -R _mysql:_mysql /usr/local/server/mysql

5. 创建库软链接：

sudo ln -s /usr/local/server/mysql/lib/lib* /usr/lib/

6.  copy配置文件到etc目录：

cp /usr/local/server/mysql/support-files/my-large.cnf /etc/my.cnf
[client]
default-character-set = utf8

[mysqld]
character-set-server = utf8
default-storage-engine = MyISAM
basedir = /usr/local/server/mysql
datadir = /var/mysql/data
log-error = /var/mysql/mysql_error.log
pid-file = /var/mysql/mysql.pid

7. 建立初始数据表：

sudo /usr/local/server/mysql/scripts/mysql_install_db --basedir=/usr/local/server/mysql --datadir=/var/mysql/data --user=_mysql

8. 设置root密码:

sudo /usr/local/server/mysql/bin/mysqladmin -u root password 'mysql'

9.启动mysql:

sudo /usr/local/server/mysql/bin/mysqld_safe --user=_mysql &

10. 测试安装是否成功：

/usr/local/server/mysql/bin/mysql -u root -p -S /tmp/mysql.sock

php编译安装:

1. 编译安装php:

2. 复制php.ini-development到编译时指定的php配制目录:

sudo cp php.ini-development /usr/local/server/php/etc/php.ini

3. 复制phpfpm的配置文件到其配制目录:

sudo cp php-fpm.conf.default php-fpm.conf

4. 重命名phpfpm执行文件为正常名称:

sudo mv php-fpm.dSYM php-fpm

5. 启动:

sudo /usr/local/server/php/sbin/php-fpm

6. 安装xdebug

1) 进入http://xdebug.org/find-binary.php网址， 输入phpinfo返回的html源码后其会自动生成安装步骤， 按照其方法编译安装， 最后变更php.ini配制文件指定xdebug.so扩展路径。

7. 安装phpunit

1) 升级pear.

sudo /usr/local/server/php/bin/pear upgrade

2) 安装phpunit.

sudo ./pear config-set auto_discover 1
sudo ./pear install pear.phpunit.de/PHPUnit

3) 测试phpunit是否安装成功.

/usr/local/server/php/bin/phpunit

#有输出帮助信息则为正常。

nginx编译安装:

1. 编译安装:

./configure --user=_www --group=_www --prefix=/usr/local/server/nginx --with-http_stub_status_module --with-http_ssl_module --with-http_sub_module
make
sudo make install

2. 修改nginx配置：

sudo vim /usr/local/server/nginx/conf/nginx.conf

#指定程序运行权限：
user _www _www;
#在http内添加一条server信息：
server {
    listen 80;
    server_name localhost;
    root /var/www;

    location ~ \.php$ {
        fastcgi_pass 127.0.0.1:9000;
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME $document_root/$fastcgi_script_name;
        include fastcgi_params;
    }
}

3.启动：

sudo /usr/local/server/nginx/sbin/nginx

#没有任何返回则说明执行成功。

参考文章:

lnap最新方案   http://www.yunwei8.com/nginx/

查了半天才发现：
Apple announced Xcode 4.3 for OSX Lion and 4.4 for OSX Mountain Lion last week. The major difference is that Xcode no longer provide an installer which is good thing because you now could update Xcode with AppStore in the future, plus it is much easier to carry the development environment with you. However, there is a little problem with this new version of Xcode, is that all command line toolsets and compilers are not visible in terminal.

解决方案一：
A simple fix is to update your PATH env:
export PATH=/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin:/Applications/Xcode.app/Contents/Developer/usr/bin:$PATH
Please be noted that clang does not reside in /Developer/usr/bin, it is now in /Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin
Now you could access to gcc, g++, git or any toolsets bundled with Xcode. For your convenience, it is recommended to include it in your .bash_profile.
解决方案二：
You can install these additional tools directly in Xcode :
Preferences > Downloads > Command Line Tools > Install