如何配置Memcached服务器

Windows下的Memcache安装

1. 下载memcache的windows稳定版，解压放某个盘下面，比如在c:\memcached

2. 在终端（也即cmd命令界面）下输入 c:\memcached\memcached.exe -d install－－安装memcached成为服务，这样才能正常运行，否则运行失败！

3. 再输入： c:\memcached\memcached.exe -d start－－启动memcached的。

以后memcached将作为windows的一个服务每次开机时自动启动。这样服务器端已经安装完毕了。

Linux下的安装：

1.下载memcached和libevent，放到 /tmp 目录下

# cd /tmp

# wget http://www.danga.com/memcached/dist/memcached-1.2.0.tar.gz

# wget http://www.monkey.org/~provos/libevent-1.2.tar.gz

2.先安装libevent：

# tar zxvf libevent-1.2.tar.gz

# cd libevent-1.2

# ./configure –prefix=/usr

# make

# make install

3.测试libevent是否安装成功：

# ls -al /usr/lib | grep libevent

lrwxrwxrwx 1 root root 21 11?? 12 17:38 libevent-1.2.so.1 ->libevent-1.2.so.1.0.3

-rwxr-xr-x 1 root root 263546 11?? 12 17:38 libevent-1.2.so.1.0.3

-rw-r–r– 1 root root 454156 11?? 12 17:38 libevent.a

-rwxr-xr-x 1 root root 811 11?? 12 17:38 libevent.la

lrwxrwxrwx 1 root root 21 11?? 12 17:38 libevent.so ->libevent-1.2.so.1.0.3

4.安装memcached，同时需要安装中指定libevent的安装位置：

# cd /tmp

# tar zxvf memcached-1.2.0.tar.gz

# cd memcached-1.2.0

# ./configure –with-libevent=/usr

# make

# make install

如果中间出现报错，请仔细检查错误信息，按照错误信息来配置或者增加相应的库或者路径。

安装完成后会把memcached放到 /usr/local/bin/memcached ，

5.测试是否成功安装memcached：

# ls -al /usr/local/bin/mem*

-rwxr-xr-x 1 root root 137986 11?? 12 17:39 /usr/local/bin/memcached

-rwxr-xr-x 1 root root 140179 11?? 12 17:39 /usr/local/bin/memcached-debug

memcached的基本设置：

1.启动Memcache的服务器端：

# /usr/local/bin/memcached -d -m 10 -u root -l 192.168.0.200 -p 12000 -c 256 -P /tmp/memcached.pid

-d选项是启动一个守护进程，

-m是分配给Memcache使用的内存数量，单位是MB，这里是10MB，

-u是运行Memcache的用户，这里是root，

-l是监听的服务器IP地址，如果有多个地址的话，这里指定了服务器的IP地址192.168.0.200，

-p是设置Memcache监听的端口，这里设置了12000，最好是1024以上的端口，

-c选项是最大运行的并发连接数，默认是1024，这里设置了256，按照你服务器的负载量来设定，

-P是设置保存Memcache的pid文件，这里是保存在 /tmp/memcached.pid，

2.如果要结束Memcache进程，执行：

# kill `cat /tmp/memcached.pid`

也可以启动多个守护进程，不过端口不能重复。

3.重启apache，service httpd restart

java的客户端连接程序：

将java_memcached-release_1.6.zip解压后的目录中的java_memcached-release_2.0.jar文件复制到java项目的lib目录下。

package utils.cache

import java.util.Date

import com.danga.MemCached.MemCachedClient

import com.danga.MemCached.SockIOPool

/**

* 使用memcached的缓存实用类.

*/

public class MemCached

{

// 创建全局的唯一实例

protected static MemCachedClient mcc = new MemCachedClient()

protected static MemCached memCached = new MemCached()

// 设置与缓存服务器的连接池

static {

// 服务器列表和其权重

String[] servers = {"127.0.0.1:11211"}

Integer[] weights = {3}

// 获取socke连接池的实例对象

SockIOPool sockIOPool = SockIOPool.getInstance()

// 设置服务器信息

sockIOPool.setServers( servers )

sockIOPool.setWeights( weights )

// 设置初始连接数、最小和最大连接数以及最大处理时间

sockIOPool.setInitConn( 5 )

sockIOPool.setMinConn( 5 )

sockIOPool.setMaxConn( 250 )

sockIOPool.setMaxIdle( 1000 * 60 * 60 * 6 )

// 设置主线程的睡眠时间

sockIOPool.setMaintSleep( 30 )

// 设置TCP的参数，连接超时等

sockIOPool.setNagle( false )

sockIOPool.setSocketTO( 3000 )

sockIOPool.setSocketConnectTO( 0 )

//sockIOPool.setFailover(bFailover)

//sockIOPool.setAliveCheck(bAliveCheck)

// 初始化连接池

sockIOPool.initialize()

// 压缩设置，超过指定大小（单位为K）的数据都会被压缩

if (memCachedClient == null)

{

mcc = new MemCachedClient(sPoolName)

mcc.setCompressEnable(true)

mcc.setCompressThreshold(4096)

mcc.setPrimitiveAsString(true)

}

}

/*

<h3>基于Spring的配置，如下：</h3>

<pre>

<bean id="memCachedService" class="com.ms.memcached.MemCachedServiceImpl">

<constructor-arg index="0" value="${memcached.pool.name}" />

<constructor-arg index="1" value="${memcached.pool.servers}" />

<constructor-arg index="2" value="${memcached.pool.initConn}" />

<constructor-arg index="3" value="${memcached.pool.maxConn}" />

<constructor-arg index="4" value="${memcached.pool.minConn}" />

<constructor-arg index="5" value="${memcached.pool.socketTO}" />

<constructor-arg index="6" value="${memcached.pool.maintSleep}" />

<constructor-arg index="7" value="${memcached.pool.nagle}" />

<constructor-arg index="8" value="${memcached.pool.failover}" />

<constructor-arg index="9" value="${memcached.pool.aliveCheck}" />

</bean>

</pre>

<h3>利用com.MS.cache.properties来设置参数，如下：</h3>

<pre>

memcached.pool.name = MS

memcached.pool.servers = 192.168.9.132:12000,192.168.9.133:12000

memcached.pool.initConn = 128

memcached.pool.maxConn = 1024

memcached.pool.minConn = 20

memcached.pool.socketTO = 3000

memcached.pool.maintSleep = 30

memcached.pool.nagle = false

memcached.pool.failover = true

memcached.pool.aliveCheck = true

</pre>

*/

/**

* 保护型构造方法，不允许实例化！

*/

protected MemCached()

{

}

/**

* 获取唯一实例.

*/

public static MemCached getInstance()

{

return memCached

}

/**

* 添加一个指定的值到缓存中.

* @param key

* @param value

*/

//新增指定key的缓存内容，但不覆盖已存在的内容。

public boolean add(String key, Object value)

{

return mcc.add(key, value)

}

//expiry过期时间

public boolean add(String key, Object value, Date expiry)

{

return mcc.add(key, value, expiry)

}

//新增或覆盖指定Key的缓存内容

public boolean set(String key, Object value)

{

return mcc.set(key, value)

}

//lExpiry过期时间

public boolean set(String key, Object value, long lExpiry)

{

return mcc.set(key, value, new Date(lExpiry))

}

//根据指定的Key获取缓存内容

public boolean get(String key)

{

return mcc.get(key)

}

//根据指定Key更新缓存内容

public boolean replace(String key, Object value)

{

return mcc.replace(key, value)

}

//lExpiry 指定的时间

public boolean replace(String key, Object value, long lExpiry)

{

return mcc.replace(key, value, new Date(lExpiry))

}

//根据指定Key删除缓存内容

public boolean delete(String key, Object value)

{

return mcc.delete(key, value)

}

//根据指定Key在指定时间后删除缓存内容

public boolean delete(String key, Object value, long lExpiry)

{

return mcc.delete(key, value, new Date(lExpiry))

}

//检测Cache中当前Key是否存在

public boolean exists(String key)

{

return mcc.exists(key)

}

//根据指定一批Key批量获取缓存内容。

/*

* @param sKeys 指定的一批Key。

* @return Object[oValue]

*/

public Object[] getMultiArray(String[] sKeys) throws ServiceException

{

return memCachedClient.getMultiArray(sKeys)

}

/**

* 根据指定一批Key批量获取缓存内容。

*

* @param sKeys 指定的一批Key。

* @return Map<sKey, oValue>

*/

public Map<String, Object>getMulti(String[] sKeys) throws ServiceException

{

return memCachedClient.getMulti(sKeys)

}

public static void main(String[] args)

{

MemCached memCached= MemCached.getInstance()

memCached.add("hello", 234)

System.out.print("get value : " + memCached.get("hello"))

}

}

那么我们就可以通过简单的像main方法中操作的一样存入一个变量，然后再取出进行查看，我们可以看到先调用了add，然后再进行get，我们运行一次 后，234这个值已经被我们存入了memcached的缓存中的了，我们将main方法中红色的那一行注释掉后，我们再运行还是可以看到get到的 value也是234，即缓存中我们已经存在了数据了。

对基本的数据我们可以操作，对于普通的POJO而言，如果要进行存储的话，那么比如让其实现java.io.Serializable接口，因为 memcached是一个分布式的缓存服务器，多台服务器间进行数据共享需要将对象序列化的，所以必须实现该接口，否则会报错的。

Entity

/**

* 获取当前实体的缓存Id

*

* @return

*/

public String getCacheId()

{

return getCacheId(this.getClass(), sBreedId)

}

get

public Breed getBreedById(String sBreedId) throws ServiceException

{

Breed breed = (Breed)memCachedService.get(getCacheId(Breed.class, sBreedId))

if(breed == null)

{

breed = service.get("breed.getBreedById", sBreedId)

if(breed != null)

{

memCachedService.set(breed.getBreedId(), breed)

}

}

return breed

}

save

memCachedService.set(spider.getCacheId(), breed)

update

memCachedService.replace(spider.getCacheId(), breed)

remove

memCachedService.delete(getCacheId(Spider.class, IbreedId))

或

memCachedService.delete(breed.getCacheId())

listAll

public List listAll() throws ServiceException

{

List breeds = new ArrayList ()

List breedIds = (List)memCachedService.get(getKeyByMap("Breed", null))

if(ObjectUtils.isEmpty(breedIds))

{

breeds = service.list("breed.getAllBreed", null)

if (!ObjectUtils.isEmpty(breeds))

{

breedIds = new ArrayList()

for (Breed breed : breeds)

{

breedIds.add(breed.getBreedId())

}

memCachedService.set(getKeyByMap("Breed", null), breedIds)

}

}

else

{

for (String sBreedId : breedIds)

{

Breed breed = getBreedById(sBreedId)

if (breed != null)

{

breeds.add(breed)

}

}

}

return breeds

}

配置修改：如果不懂代码的话，不要伸手，后果自负。

负载状态：memcached运行中的相关状态。其中最重要的是hit这个参数，也就是命中率。当然是越高越好了。

性能调整：前面IP和端口不要改。缓存大小根据实际情况调整。根据什么来调整呢？回到负载状态栏，有一个“当前已使用内存”，看这个数字来调整。比如默认分配给memcached一共64M内存，但是已使用内存62M就说明memcached可用内存快要满了，这时候就手动改大一点，比如128M。具体数字根据每天流量情况来定。

Memcached的目的就是把所有文章内容都扔进内存，这样用户来访时直接读取内存中的内容，跳过了数据库，所以使用memcached后网站打开感觉特别快。比如网站每天发几十篇文章，可能这个数字就调整大一点，防止不够用了

1、使用高效的缓存插件

WordPress的插件们是非常有用的， 我推荐一款缓存插件可以改善页面载入时间，它就是W3 Total Cache，有了这个插件之后咱就不再推荐你其他缓存插件了，因为所有缓存插件有的功能它都有了，而且安装和使用非常方便。

拥有这款插件之后，你的页面载入速度会加快，因为网站的主要元素已经被缓存了。

2. 使用内容分发网络 (CDN)

基本上所有你喜欢的大网站都会使用CDN。简单来说，CDN是把你站点上的文件们（CSS\JS\图片等）发布到最接近用户所在的网络区域，让用户就近下载，这样就能提高站点运行速度。在国内ChinaCache是比较有名的CDN供应商，不过价格贵了一些，像各大门户网站，比如腾讯、新浪、网易等等都是用ChinaCache。所以不管你在哪里，访问这些门户网站都会觉得速度很快。当然啦，对于小站来说，这个成本可能会高一些，

所以，你无论是在南方，或者北方，还是在北美，访问这些门户网站，感觉速度都很快，最主要的原因之一就是CDN发挥了效果。一般小网站是用不起这服务的，所以慢点就慢点了吧，可以租用互联互通的6线机房（6线机房是指包括网通、电信、铁通、移动、联通、教育网等多线接入的骨干网IDC机房，彻底消除各地网络瓶颈，保证互联网访问畅通无阻的高速机房。）

顺便提一下，还有一个Wordpress插件叫Free-CDN，号称也能达到类似的效果，虽然我还没有做过测试…

3、图片优化很重要

Yahoo! 有一个图片优化软件叫Smush.it可以最大程度无损压缩图片，不过，除非你超级有耐心，否则一张张压缩图片的话太浪费时间了，好在，还有一个很给力的WP插件叫WP-SmushIt，这货可以为你网站上所有的图片做一次性压缩，所以没有理由不去用它。

4、优化你的WP数据库

你可以用WP-Optimize这个插件来优化你的WP数据库（清理spam，反复改版的文章，草稿，表格等等为你的服务器腾出更多空间从而提升效率）；还有一些插件如WP-Cleaner，DB-Manger等。

5、开启防盗链机制

盗链是带宽的窃贼，当其他网站直接引用你站点的图片的时候，这会影响占用你本身的服务器资源从而影响网站运行效率，你的站点越出名，就会有越多的人盗用你的图片，解决方法是Wordpress有现成的插件Hotlink Protection。当然也可以通过重写htaccess文件来达到同样的效果，欲深入了解的童鞋可以询问自己的空间商如何设置。

6、为文件添加过期时间

关于这个文件过期时间，听起来很玄乎，其实就是通过header报文来指定特定类型的文件在浏览器中的缓存时间。有些文件（例如样式表中调用的背景图片和一些装饰性图片）其实在很长一段时间内这些图片都不会有很大的变化，所以对这类文件我们不妨设置长一些的缓存时间，这样浏览器就不需要每次从服务器下载这些文件而直接从缓存中读取，这样绝对可以提升加载速度。

当然，所以做法很简单，只需要在网站的.htaccess文件中加入以下代码，

<IfModule mod_expires.c>

ExpiresActive On

ExpiresDefault A600

ExpiresByType image/x-icon A2592000

ExpiresByType application/x-javascript A604800

ExpiresByType text/css A604800

ExpiresByType image/gif A2592000

ExpiresByType image/png A2592000

ExpiresByType image/jpeg A2592000

ExpiresByType text/plain A86400

ExpiresByType application/x-shockwave-flash A2592000

ExpiresByType video/x-flv A2592000

ExpiresByType application/pdf A2592000

ExpiresByType text/html A600

</IfModule>

稍微解释一下，text/css表示样式表文件，text/plain代表的纯文本类文件，依次类推。其中A2592000就表示这种类型文件在浏览器中的缓存时间，以秒为单位。一天86400秒，2592000就表示这类文件可以缓存30天。

如果你不是经常修改模板，那样式表文件和javasctipt文件基本上也可以设置缓存一周到一个月左右。text/html文件不要设置太长的缓存时间，因为这些东西修改的频率很高，一天更新一次是有必要的。

7、为你的图片添加延时加载

延时加载就是当用户停留在第一屏的时候，不加载任何第一屏以下的图片信息，只有当用户把鼠标往下滚动的时候，这些图片才开始加载。这玩意儿不仅可以提升站点载入速度，更是可以节省带宽。要轻松的拥有这项功能，请安装WP的jQuery Image Lazy Load 插件吧。

8、控制文章草稿存数数

通常一篇博文我会保存10次以上的草稿，而Wordpress会无限制的存储每个草稿；如果我的博文已经发布了，为啥我还需要这些储存的草稿文章呢？所以这就是为啥我会用 Revision Control 插件来确保这些草稿内容的最小化。通常我会设置只存储2-3篇草稿来防止万一，但存储的数量绝对不会太高，否则你的WordPress backend只会被这些无意义的内容塞满从而降低运行效率。

---