本文目录：
windows memcached 怎么用
memcached在windows7上的安装问题 错误： 通过cmd命令行进入到D:webEvememcached(下载后的解压目录) 运行 memcached.exe -d install 报错 failed to install service or service already installed 解决方法： 管理员身份安装，首先找出cmd.exe的原文件 右击以管理员身份运行，接下来就OK(win7下的用户还真麻烦). Windows下的Memcache安装： 1. 下载memcache的windows稳定版，解压放某个盘下面，比如在D:webEvememcached 2. 在终端（也即cmd命令界面）下输入 ‘D:webEvememcachedmemcached.exe -d install’ 安装 3. 再输入:’D:webEvememcachedmemcached.exe -d start’ 启动。NOTE: 以后memcached将作为windows的一个服务每次开机时自动启动。这样服务器端已经安装完毕了。 4.下载php_memcache.dll，请自己查找对应的php版本的文件 5. 在php.ini 加入一行 ‘extension=php_memcache.dll’ 6.重新启动Apache，然后查看一下phpinfo，如果有memcache，那么就说明安装成功！ memcached的基本设置： -p 监听的端口 -l 连接的IP地址, 默认是本机 -d start 启动memcached服务 -d restart 重起memcached服务 -d stopshutdown 关闭正在运行的memcached服务 -d install 安装memcached服务 -d uninstall 卸载memcached服务 -u 以的身份运行 (仅在以root运行的时候有效) -m 最大内存使用，单位MB。默认64MB -M 内存耗尽时返回错误，而不是删除项 -c 最大同时连接数，默认是1024 -f 块大小增长因子，默认是1.25 -n 最小分配空间，key+value+flags默认是48 -h 显示帮助
python 操作memcached
1、设定缓存放在那里：CACHE_BACKEND
也可以使用memcached:CACHE_BACKEND = ‘memcached://127.0.0.1:11211/’
多个memcached:CACHE_BACKEND = ‘memcached://172.19.26.240:11211;172.19.26.242:11211/’
/// pip install python-memcached
2、python 操作memcached:
import memcache
mc = memcache.Client([‘139.129.5.191:12000’], debug=True)
mc.set(“name”, “python”)
ret = mc.get(‘name’)
print (ret)
python
3、设置权重
import memcache
mc = memcache.Client([(‘1.1.1.1:12000’, 1), (‘1.1.1.2:12000’, 2),(‘1.1.1.3:12000’,3)])
mc.set(‘k1′,’value1’)
ret = mc.get(‘k1’)
print (ret)
4、已经存在的键重复添加会出错：
import memcache
mc = memcache.Client([‘0.0.0.0:12000’])
mc.add(‘k1’, ‘v1’)
mc.add(‘k1’, ‘v2’) # 报错，对已经存在的key重复添加，失败！！！
例如：
ret1 = mc.add(‘name’,’tom’)
print(refalse)
ret2 = mc.add(‘name’,’jack’)
print(retrue)
结果：
False #当已经存在key 那么返回false
True #如果不存在key 那么返回treue
5、替换操作：replace,如果键不存在，出错
import memcache
mc = memcache.Client([‘0.0.0.0:12000’])
mc.set(‘name’,’tom’)
re = mc.get(‘name’)
print(re)
rereplace = mc.replace(‘name’,’jack’)
re = mc.get(‘name’)
print(rereplace,re)
结果：
tom #第一次赋值
True jack #如果存在key那么修改成功为yaoyao 返回True
rereplace = mc.replace(‘name1′,’hahaha’)
re = mc.get(‘name1’)
print(rereplace,re)
结果：
False None #如果不存在key，修改失败，返回空值
6、set:键值存在，就修改，不存在，则创建
import memcache
mc = memcache.Client([‘0.0.0.0:12000’])
mc.set(‘name’,’tom’)
re = mc.get(‘name’)
print(‘set用法’,re) #设置一个键值对
dic = {‘name’:’to,’,’age’:’19’,’job’:’IT’}
mc.set_multi(dic) #设置多个键值对
mcname = mc.get(‘name’)
mcage = mc.get(‘age’)
mcjob = mc.get(‘job’)
print(‘set_multi用法:’,mcname,mcage,mcjob)
7、delete:
import memcache
mc = memcache.Client([‘0.0.0.0:12000’])
mc.set(‘name’,’tom’)
re = mc.get(‘name’)
print(‘存在’,re)
mc.delete(‘name’)
re = mc.get(‘name’)
print(‘删除’,re) #删除一个键值对
8、get
import memcache
mc = memcache.Client([‘0.0.0.0:12000’])
mc.set(‘name’,’tom’)
re = mc.get(‘name’)
print(‘get’,re) #获取一个键值对
dic = {‘name’:’to,’,’age’:’19’,’job’:’IT’}
mc.set_multi(dic)
regetmu=mc.get_multi([‘name’,’age’,’job’])
print(‘get_multi’,re) #获取多个键值对的值
9、append,prepend
import memcache
mc = memcache.Client([‘0.0.0.0:12000’])
mc.set(‘num’,’第一|’)
re = mc.get(‘num’)
print(re)
mc.append(‘num’,’追加第二个’) #在第一后面追加
re = mc.get(‘num’)
print(re)
mc.prepend(‘num’,’我是零个’) #在第一前面追加
re = mc.get(‘num’)
print(re)
结果：
第一|
第一|追加第二个
我是零个第一|追加第二个
10、decr,incr自增自减
import memcache
mc = memcache.Client([‘0.0.0.0:12000’])
mc.set(‘num’,’1′)
re = mc.get(‘num’)
print(‘我是没加过的值’,re)
mc.incr(‘num’,’9′)
re = mc.get(‘num’)
print(‘我是加上新增后的值’,re)
mc.decr(‘num’,’5′)
re = mc.get(‘num’)
print(‘我是减去的值’,re)
我是没加过的值 1
我是加上新增后的值 10
是减去的值 5
11、锁机制：gets cas
import memcache
mc = memcache.Client([‘0.0.0.0:12000’],cache_cas=True)
mc.set(‘count’,’10’)
reget = mc.get(‘count’)
print(‘件数’,reget)
regets = mc.gets(‘count’)
print(regets)
下面的设置将会执行失败，剖出异常，从而避免非正常数据的产生
recas = mc.cas(‘count’,’11’)
print(recas)
regets = mc.gets(‘count’)
print(‘修改’,regets)
Memcached 在 Spring 里怎么用
本文将对在Java环境下Memcached应用进行详细介绍。Memcached主要是集群环境下的缓存解决方案，可以运行在Java或者.NET平台上，这里我们主要讲的是Windows下的Memcached应用。
这些天在设计SNA的架构，接触了一些远程缓存、集群、session复制等的东西，以前做企业应用的时候感觉作用不大，现在设计面对internet的系统架构时就非常有用了，而且在调试后看到压力测试的情况还是比较好的。
在缓存的选择上有过很多的思考，虽然说memcached结合java在序列化上性能不怎么样，不过也没有更好的集群环境下的缓存解决方案了，就选择了memcached。本来计划等公司买的服务器到位装个linux再来研究memcached，但这两天在找到了一个windows下的Memcached版本，就动手开始调整现有的框架了。
Windows下的Server端很简单，不用安装，双击运行后默认服务端口是11211，没有试着去更改端口，因为反正以后会用Unix版本，到时再记录安装步骤。下载客户端的JavaAPI包，接口非常简单，参考API手册上就有现成的例子。
目标，对旧框架缓存部分进行改造：
1、缓存工具类
2、hibernate的provider
3、用缓存实现session机制
今天先研究研究缓存工具类的改造，在旧框架中部分函数用了ehcache对执行结果进行了缓存处理，现在目标是提供一个缓存工具类，在配置文件中配置使用哪种缓存（memcached或ehcached），使其它程序对具体的缓存不依赖，同时使用AOP方式来对方法执行结果进行缓存。
首先是工具类的实现：
在Spring中配置
Java代码
bean id=”cacheManager”
class=”cha-ae57-fdca-09db-3d73 org.springframework.cache.ehcache.EhCacheManagerFactoryBean”
property name=”configLocation”
valueclasspath:ehcache.xmlvalue
property
bean
bean id=”localCache”
class=”cha-fdca-09db-3d73-cc39 org.springframework.cache.ehcache.EhCacheFactoryBean”
property name=”cacheManager” ref=”cacheManager” /
property name=”cacheName”
value=”×××.cache.LOCAL_CACHE” /
bean
bean id=”cacheService”
class=”cha-09db-3d73-cc39-1834 ×××.core.cache.CacheService” init-method=”init” destroy-method=”destory”
property name=”cacheServerList” value=”${cache.servers}”/
property name=”cacheServerWeights” value=”${cache.cacheServerWeights}”/
property name=”cacheCluster” value=”${cache.cluster}”/
property name=”localCache” ref=”localCache”/
bean
bean id=”cacheManager”
class=”cha-2685-46fc-bead-ea9c org.springframework.cache.ehcache.EhCacheManagerFactoryBean”
property name=”configLocation”
valueclasspath:ehcache.xmlvalue
property
bean
bean id=”localCache”
class=”cha-46fc-bead-ea9c-1d55 org.springframework.cache.ehcache.EhCacheFactoryBean”
property name=”cacheManager” ref=”cacheManager” /
property name=”cacheName”
value=”×××.cache.LOCAL_CACHE” /
bean
bean id=”cacheService”
class=”cha-bead-ea9c-1d55-0586 ×××.core.cache.CacheService” init-method=”init” destroy-method=”destory”
property name=”cacheServerList” value=”${cache.servers}”/
property name=”cacheServerWeights” value=”${cache.cacheServerWeights}”/
property name=”cacheCluster” value=”${cache.cluster}”/
property name=”localCache” ref=”localCache”/
bean
在properties文件中配置${cache.servers} ${cache.cacheServerWeights} ${cache.cluster}
具体工具类的代码
Java代码
/**
* @author Marc
*
*/
public class CacheService {
private Log logger = LogFactory.getLog(getClass());
private Cache localCache;
String cacheServerList;
String cacheServerWeights;
boolean cacheCluster = false;
int initialConnections = 10;
int minSpareConnections = 5;
int maxSpareConnections = 50;
long maxIdleTime = 1000 * 60 * 30; // 30 minutes
long maxBusyTime = 1000 * 60 * 5; // 5 minutes
long maintThreadSleep = 1000 * 5; // 5 seconds
int socketTimeOut = 1000 * 3; // 3 seconds to block on reads
int socketConnectTO = 1000 * 3; // 3 seconds to block on initial
// connections. If 0, then will use blocking
// connect (default)
boolean failover = false; // turn off auto-failover in event of server
// down
boolean nagleAlg = false; // turn off Nagle’s algorithm on all sockets in
// pool
MemCachedClient mc;
public CacheService(){
mc = new MemCachedClient();
mc.setCompressEnable(false);
}
/**
* 放入
*
*/
public void put(String key, Object obj) {
Assert.hasText(key);
Assert.notNull(obj);
Assert.notNull(localCache);
if (this.cacheCluster) {
mc.set(key, obj);
} else {
Element element = new Element(key, (Serializable) obj);
localCache.put(element);
}
}
/**
* 删除
*/
public void remove(String key){
Assert.hasText(key);
Assert.notNull(localCache);
if (this.cacheCluster) {
mc.delete(key);
}else{
localCache.remove(key);
}
}
/**
* 得到
*/
public Object get(String key) {
Assert.hasText(key);
Assert.notNull(localCache);
Object rt = null;
if (this.cacheCluster) {
rt = mc.get(key);
} else {
Element element = null;
try {
element = localCache.get(key);
} catch (CacheException cacheException) {
throw new DataRetrievalFailureException(“Cache failure: “
+ cacheException.getMessage());
}
if(element != null)
rt = element.getValue();
}
return rt;
}
/**
* 判断是否存在
*
*/
public boolean exist(String key){
Assert.hasText(key);
Assert.notNull(localCache);
if (this.cacheCluster) {
return mc.keyExists(key);
}else{
return this.localCache.isKeyInCache(key);
}
}
private void init() {
if (this.cacheCluster) {
String[] serverlist = cacheServerList.split(“,”);
Integer[] weights = this.split(cacheServerWeights);
// initialize the pool for memcache servers
SockIOPool pool = SockIOPool.getInstance();
pool.setServers(serverlist);
pool.setWeights(weights);
pool.setInitConn(initialConnections);
pool.setMinConn(minSpareConnections);
pool.setMaxConn(maxSpareConnections);
pool.setMaxIdle(maxIdleTime);
pool.setMaxBusyTime(maxBusyTime);
pool.setMaintSleep(maintThreadSleep);
pool.setSocketTO(socketTimeOut);
pool.setSocketConnectTO(socketConnectTO);
pool.setNagle(nagleAlg);
pool.setHashingAlg(SockIOPool.NEW_COMPAT_HASH);
pool.initialize();
logger.info(“初始化memcached pool!”);
}
}
private void destory() {
if (this.cacheCluster) {
SockIOPool.getInstance().shutDown();
}
}
}
/**
* @author Marc
*
*/
public class CacheService {
private Log logger = LogFactory.getLog(getClass());
private Cache localCache;
String cacheServerList;
String cacheServerWeights;
boolean cacheCluster = false;
int initialConnections = 10;
int minSpareConnections = 5;
int maxSpareConnections = 50;
long maxIdleTime = 1000 * 60 * 30; // 30 minutes
long maxBusyTime = 1000 * 60 * 5; // 5 minutes
long maintThreadSleep = 1000 * 5; // 5 seconds
int socketTimeOut = 1000 * 3; // 3 seconds to block on reads
int socketConnectTO = 1000 * 3; // 3 seconds to block on initial
// connections. If 0, then will use blocking
// connect (default)
boolean failover = false; // turn off auto-failover in event of server
// down
boolean nagleAlg = false; // turn off Nagle’s algorithm on all sockets in
// pool
MemCachedClient mc;
public CacheService(){
mc = new MemCachedClient();
mc.setCompressEnable(false);
}
/**
* 放入
*
*/
public void put(String key, Object obj) {
Assert.hasText(key);
Assert.notNull(obj);
Assert.notNull(localCache);
if (this.cacheCluster) {
mc.set(key, obj);
} else {
Element element = new Element(key, (Serializable) obj);
localCache.put(element);
}
}
/**
* 删除
*/
public void remove(String key){
Assert.hasText(key);
Assert.notNull(localCache);
if (this.cacheCluster) {
mc.delete(key);
}else{
localCache.remove(key);
}
}
/**
* 得到
*/
public Object get(String key) {
Assert.hasText(key);
Assert.notNull(localCache);
Object rt = null;
if (this.cacheCluster) {
rt = mc.get(key);
} else {
Element element = null;
try {
element = localCache.get(key);
} catch (CacheException cacheException) {
throw new DataRetrievalFailureException(“Cache failure: “
+ cacheException.getMessage());
}
if(element != null)
rt = element.getValue();
}
return rt;
}
/**
* 判断是否存在
*
*/
public boolean exist(String key){
Assert.hasText(key);
Assert.notNull(localCache);
if (this.cacheCluster) {
return mc.keyExists(key);
}else{
return this.localCache.isKeyInCache(key);
}
}
private void init() {
if (this.cacheCluster) {
String[] serverlist = cacheServerList.split(“,”);
Integer[] weights = this.split(cacheServerWeights);
// initialize the pool for memcache servers
SockIOPool pool = SockIOPool.getInstance();
pool.setServers(serverlist);
pool.setWeights(weights);
pool.setInitConn(initialConnections);
pool.setMinConn(minSpareConnections);
pool.setMaxConn(maxSpareConnections);
pool.setMaxIdle(maxIdleTime);
pool.setMaxBusyTime(maxBusyTime);
pool.setMaintSleep(maintThreadSleep);
pool.setSocketTO(socketTimeOut);
pool.setSocketConnectTO(socketConnectTO);
pool.setNagle(nagleAlg);
pool.setHashingAlg(SockIOPool.NEW_COMPAT_HASH);
pool.initialize();
logger.info(“初始化memcachedpool!”);
}
}
private void destory() {
if (this.cacheCluster) {
SockIOPool.getInstance().shutDown();
}
}
}
然后实现函数的AOP拦截类，用来在函数执行前返回缓存内容
Java代码
public class CachingInterceptor implements MethodInterceptor {
private CacheService cacheService;
private String cacheKey;
public void setCacheKey(String cacheKey) {
this.cacheKey = cacheKey;
}
public void setCacheService(CacheService cacheService) {
this.cacheService = cacheService;
}
public Object invoke(MethodInvocation invocation) throws Throwable {
Object result = cacheService.get(cacheKey);
//如果函数返回结果不在Cache中,执行函数并将结果放入Cache
if (result == null) {
result = invocation.proceed();
cacheService.put(cacheKey,result);
}
return result;
}
}
public class CachingInterceptor implements MethodInterceptor {
private CacheService cacheService;
private String cacheKey;
public void setCacheKey(String cacheKey) {
this.cacheKey = cacheKey;
}
public void setCacheService(CacheService cacheService) {
this.cacheService = cacheService;
}
public Object invoke(MethodInvocation invocation) throws Throwable {
Object result = cacheService.get(cacheKey);
//如果函数返回结果不在Cache中,执行函数并将结果放入Cache
if (result == null) {
result = invocation.proceed();
cacheService.put(cacheKey,result);
}
return result;
}
}
Spring的AOP配置如下：
Java代码
aop:config proxy-target-class=”cha-ea9c-1d55-0586-eb9b true”
aop:advisor
pointcut=”execution(* ×××.PoiService.getOne(..))”
advice-ref=”PoiServiceCachingAdvice” /
aop:config
bean id=”BasPoiServiceCachingAdvice”
class=”cha-1d55-0586-eb9b-3aa8 ×××.core.cache.CachingInterceptor”
property name=”cacheKey” value=”PoiService” /
property name=”cacheService” ref=”cacheService” /
bean
转载
java中memcache怎么用
1. memcached client for java客户端API：memcached client for java
引入jar包：java-memcached-2.6.2.jar
package com.pcitc.memcached;
import com.danga.MemCached.*;
public class TestMemcached {
public static void main(String[] args) {
/* 初始化SockIOPool，管理memcached的连接池 */
String[] servers = { “192.168.1.111:11211” };
SockIOPool pool = SockIOPool.getInstance();
pool.setServers(servers);
pool.setFailover(true);
pool.setInitConn(10);
pool.setMinConn(5);
pool.setMaxConn(250);
pool.setMaintSleep(30);
pool.setNagle(false);
pool.setSocketTO(3000);
pool.setAliveCheck(true);
pool.initialize();
/* 建立MemcachedClient实例 */
MemCachedClient memCachedClient = new MemCachedClient();
for (int i = 0; i 10; i++) {
/* 将对象加入到memcached缓存 */
boolean success = memCachedClient.set(“” + i, “Hello!”);
/* 从memcached缓存中按key值取对象 */
String result = (String) memCachedClient.get(“” + i);
System.out.println(String.format(“set( %d ): %s”, i, success));
System.out.println(String.format(“get( %d ): %s”, i, result));
}
}
}
2. spymemcached客户端API：spymemcached client
引入jar包：spymemcached-2.10.3.jar
package com.pcitc.memcached;
import java.net.InetSocketAddress;
import java.util.concurrent.Future;
import net.spy.memcached.MemcachedClient;
public class MClient {
public static void main(String[] args) {
setValue();
getValue();
}
// 用spymemcached将对象存入缓存
public static void setValue() {
try {
/* 建立MemcachedClient 实例，并指定memcached服务的IP地址和端口号 */
MemcachedClient mc = new MemcachedClient(new InetSocketAddress(
“192.168.1.111”, 11211));
FutureBoolean b = null;
/* 将key值，过期时间(秒)和要缓存的对象set到memcached中 */
b = mc.set(“neead”, 900, “someObject”);
if (b.get().booleanValue() == true) {
mc.shutdown();
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
// 用spymemcached从缓存中取得对象
public static void getValue() {
try {
/* 建立MemcachedClient 实例，并指定memcached服务的IP地址和端口号 */
MemcachedClient mc = new MemcachedClient(new InetSocketAddress(
“192.168.1.111”, 11211));
/* 按照key值从memcached中查找缓存，不存在则返回null */
Object b = mc.get(“neead”);
mc.shutdown();
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
3.两种API比较
memcached client for java：较早推出的memcached JAVA客户端API，应用广泛，运行比较稳定。
spymemcached：A simple, asynchronous, single-threaded memcached client written in java. 支持异步，单线程的memcached客户端，用到了java1.5版本的concurrent和nio，存取速度会高于前者，但是稳定性不好，测试中常报timeOut等相关异常。
由于memcached client for java发布了新版本，性能上有所提高，并且运行稳定，所以建议使用memcached client for java
【memcached怎么用】的内容来源于互联网，如引用不当，请联系我们修改。
