/******************接口类：ICache.java ********************/
package com.avit.msip.cache;
public interface ICache {
public Object get(String key);
public boolean set(String key, Object value);
public boolean set(String key, Object value, int expireTime);
public boolean keyExists(String key);
public boolean delete(String key);
public boolean cas(String key, Object value, long casUnique);
public CacheItem getCacheItem(String key);
public long incr(String key, long value);
public long incr(String key, long value, long defaultValue);
public long decr(String key, long value);
}
/******************依赖类CacheItem .java ********************/
package com.avit.msip.cache;
/**
* 该类记录了缓存项的版本号和缓存值，
* 其中缓存项主要用于解决同一item被多个线程更改的并发问题
*/
public class CacheItem {
//缓存项对应的版本号
public long casUnique;
//缓存项对应的值
public Object value;
public CacheItem(){
}
public CacheItem(Object value, long casUnique){
this.casUnique=casUnique;
this.value=value;
}
public long getCasUnique(){
return casUnique;
}
public Object getValue(){
return value;
}
}
/******************实现类XMemcachedCached .java ********************/
package com.avit.msip.cache.impl;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
import net.rubyeye.xmemcached.GetsResponse;
import net.rubyeye.xmemcached.MemcachedClient;
import net.rubyeye.xmemcached.XMemcachedClientBuilder;
import net.rubyeye.xmemcached.exception.MemcachedException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.avit.msip.cache.CacheItem;
import com.avit.msip.cache.ICache;
import com.avit.msip.common.utils.SystemProperties;
public class XMemcachedCached implements ICache {
private static final Logger log = LoggerFactory.getLogger(XMemcachedCached.class);
private static final int EXPIRE_TIME = Integer.parseInt(SystemProperties.getProperty("expiredTime", "0"));
private XMemcachedClientBuilder builder;
private MemcachedClient client;
public XMemcachedCached() {
}
/**
* <p>
* Title:
* </p>
* <p>
* Description: 初始化调用build
* </p>
*/
public void init() {
try {
client = builder.build();
} catch (IOException e) {
log.error("xmemcached build client io errors.", e);
}
}
public CacheItem getCacheItem(String key) {
CacheItem cacheItem = null;
try {
GetsResponse<?> gr = client.gets(key);
if (gr != null) {
cacheItem = new CacheItem(gr.getValue(), gr.getCas());
}
} catch (TimeoutException e) {
log.error("xmemcached get cachitem timeout errors.", e);
} catch (InterruptedException e) {
log.error("xmemcached get cachitem interrupt errors.", e);
} catch (MemcachedException e) {
log.error("xmemcached get cachitem memcached errors.", e);
}
return cacheItem;
}
public long incr(String key, long value) {
long returnValue = 0;
try {
returnValue = client.incr(key, value);
} catch (TimeoutException e) {
log.error("xmemcached get timeout errors.", e);
} catch (InterruptedException e) {
log.error("xmemcached get interrupt errors.", e);
} catch (MemcachedException e) {
log.error("xmemcached get memcached errors.", e);
}
return returnValue;
}
public long incr(String key, long value, long defaultValue) {
long returnValue = 0;
try {
returnValue = client.incr(key, value,defaultValue);
} catch (TimeoutException e) {
log.error("xmemcached get timeout errors.", e);
} catch (InterruptedException e) {
log.error("xmemcached get interrupt errors.", e);
} catch (MemcachedException e) {
log.error("xmemcached get memcached errors.", e);
}
return returnValue;
}
public long decr(String key, long value) {
long returnValue = 0;
try {
returnValue = client.decr(key, value);
} catch (TimeoutException e) {
log.error("xmemcached get timeout errors.", e);
} catch (InterruptedException e) {
log.error("xmemcached get interrupt errors.", e);
} catch (MemcachedException e) {
log.error("xmemcached get memcached errors.", e);
}
return returnValue;
}
public boolean set(String key, Object value) {
boolean flag = false;
try {
flag = client.set(key, 0, value);
} catch (TimeoutException e) {
log.error("xmemcached set timeout errors.", e);
} catch (InterruptedException e) {
log.error("xmemcached set interrupt errors.", e);
} catch (MemcachedException e) {
log.error("xmemcached set memcached errors.", e);
}
return flag;
}
/**
* save object to cache
*
* @param key
* @param value
* @param expireTime cache expried time( should not contain *) , unit:second , default value 0 xmemcached means one month
* @return
*/
public boolean set(String key, Object value, int expireTime) {
boolean flag = false;
try {
flag = client.set(key, expireTime, value);
} catch (TimeoutException e) {
log.error("xmemcached set timeout errors.", e);
} catch (InterruptedException e) {
log.error("xmemcached set interrupt errors.", e);
} catch (MemcachedException e) {
log.error("xmemcached set memcached errors.", e);
}
return flag;
}
/**
* (non-Javadoc)
* <p>
* Title: keyExists
* </p>
* <p>
* Description: 判断是否存在key
* </p>
*
* @param key
* @return
*
*/
public boolean keyExists(String key) {
return get(key) != null;
}
public boolean cas(String key, Object value, long casUnique) {
boolean flag = false;
try {
flag = client.cas(key, EXPIRE_TIME, value, casUnique);
} catch (TimeoutException e) {
log.error("xmemcached cas timeout errors.", e);
} catch (InterruptedException e) {
log.error("xmemcached cas interrupt errors.", e);
} catch (MemcachedException e) {
log.error("xmemcached cas memcached errors.", e);
}
return flag;
}
/**
* (non-Javadoc)
* <p>
* Title: get
* </p>
* <p>
* Description: get
* </p>
*
* @param key
* @return
*
*/
public Object get(String key) {
Object obj = null;
try {
obj = client.get(key);
} catch (TimeoutException e) {
log.error("xmemcached get timeout errors.", e);
} catch (InterruptedException e) {
log.error("xmemcached get interrupt errors.", e);
} catch (MemcachedException e) {
log.error("xmemcached get memcached errors.", e);
}
return obj;
}
/**
* (non-Javadoc)
* <p>
* Title: delete
* </p>
* <p>
* Description: delete
* </p>
*
* @param key
* @return
*
*/
public boolean delete(String key) {
boolean flag = false;
try {
flag = client.delete(key);
} catch (TimeoutException e) {
log.error("xmemcached delete timeout errors.", e);
} catch (InterruptedException e) {
log.error("xmemcached delete interrupt errors.", e);
} catch (MemcachedException e) {
log.error("xmemcached delete memcached errors.", e);
}
return flag;
}
/**
* @description: shutdown 销毁时调用 void
* @author: zhayong@avit.com.cn
* @date: 2013-1-6 下午2:01:47
*/
public void shutdown() {
try {
client.shutdown();
} catch (IOException e) {
log.error("xmemcached shutdown io errors.", e);
}
}
public XMemcachedClientBuilder getBuilder() {
return builder;
}
public void setBuilder(XMemcachedClientBuilder builder) {
this.builder = builder;
}
}
/**********************************对外使用类CacheManager.java************************************************/
package com.avit.msip.cache;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.avit.msip.common.utils.SystemProperties;
public class CacheManager {
public static Logger log = LoggerFactory.getLogger(CacheManager.class);
// 是否开启缓存
public static final String ISCACHEDON = "isCacheOn";
// 开启缓存的类型
public static final String CACHETYPE = "cacheType";
//没有在配置文件中配置，默认是关闭的
public static String ISCACHEONFLAG = SystemProperties.getProperty(ISCACHEDON, "false").trim();
public static Long currentOfferID = 0L;
public static ICache cache;
public static Map<String, Object> memoryMap = new ConcurrentHashMap<String, Object>();
static {
if (isCacheOn()) {
log.info("-------------------CacheManager init...");
String cacheType = SystemProperties.getProperty(CACHETYPE, "0");
// 不用ehcache时，先不加载ehcache的配置文件，以免加载后耗用系统内存，若需要使用ehcache时，修改此处即可
ApplicationContext ctx = new ClassPathXmlApplicationContext(
new String[]{"applicationContext-xmemcached.xml"});
// ApplicationContext ctx = new ClassPathXmlApplicationContext(new
// String[]{"applicationContext-memcached.xml",
// "applicationContext-ehcache.xml"});
// 根据配置的cache类型初始化
if ("0".equals(cacheType)) {
cache = (ICache) ctx.getBean("xmemCachedClient");
} else {
cache = (ICache) ctx.getBean("ehCachedClient");
}
}
}
/**
* 是否使用缓存
*
* @return
*/
public static boolean isCacheOn() {
if (ISCACHEONFLAG != null && ISCACHEONFLAG.equalsIgnoreCase("true")) {
return true;
} else {
return false;
}
}
/**
* 为了避免关键字冲突，统一cache记录的关键字组成格式： 关键字 + 功能名称
* 例如：将tsid（假设此处值为1）与ErmServer对应关系保存至缓存时，关键字可以为:"1"+"_"+"Tsid_ErmServer"
* 其中功能名称部分（即对应Tsid_ErmServer）最好在常量文件进行统一定义，且功能名称部分可以反映该缓存的结构信息
*
* @param keyWord
* @param code
* @return
*/
public static String buildKey(String keyWord, String code) {
StringBuffer sb = new StringBuffer();
// sb.append(CacheUtil.SERVERNAME).append("_").append(keyWord).append("_").append(functionName);
// 支持分布式部署
sb.append(keyWord).append("_").append(code);
return sb.toString();
}
public static Object get(String key) {
if (isCacheOn()) {
return cache.get(key);
} else {
return memoryMap.get(key);
}
}
public static boolean set(String key, Object value) {
if (value == null) {
return false;
}
if (isCacheOn()) {
return cache.set(key, value);
} else {
memoryMap.put(key, value);
return true;
}
}
public static boolean set(String key, Object value, int expireTime) {
if (value == null) {
return false;
}
if (isCacheOn()) {
return cache.set(key, value, expireTime);
} else {
memoryMap.put(key, value);
return true;
}
}
/**
* 加上一个值
*
* @param key
* @param value
* @return
*/
public static long incr(String key, long value) {
if (isCacheOn()) {
return cache.incr(key, value);
} else {
long memvalue = (Long) memoryMap.get(key);
memoryMap.put(key, memvalue + value);
return memvalue + value;
}
}
/**
* 如果 第一次设置默认值 defaultValue
*
* @param key
* @param value
* @param defaultValue
* @return
*/
public static long addIncr(String key, long defaultValue) {
if (isCacheOn()) {
cache.delete(key);
return cache.incr(key, defaultValue, defaultValue);
} else {
memoryMap.put(key, defaultValue);
return defaultValue;
}
}
/**
* 减去一个值
*
* @param key
* @param value
* @return
*/
public static long decr(String key, long value) {
if (isCacheOn()) {
return cache.decr(key, value);
} else {
long memvalue = (Long) memoryMap.get(key);
memoryMap.put(key, memvalue - value);
return memvalue - value;
}
}
public static boolean keyExists(String key) {
if (isCacheOn()) {
return cache.keyExists(key);
}else{
return memoryMap.containsKey(key);
}
}
public static boolean delete(String key) {
if (isCacheOn()) {
return cache.delete(key);
} else {
memoryMap.remove(key);
return true;
}
}
/**
* 根据缓存中对应key的缓存项的版本号来判断是否可以更新缓存中key对应的value
* 若缓存中对应key的缓存项的版本号与casUnique值一致，则可以更新并返回true，否则返回false
*
* @param key
* @param value
* @param casUnique
* @return
*/
public static boolean cas(String key, Object value, long casUnique) {
if (isCacheOn()) {
return cache.cas(key, value, casUnique);
} else {
memoryMap.put(key, value);
return true;
}
}
/**
* 获取缓存中对应key的缓存项，缓存项有value和版本号casUnique（防止更新缓存时出现不一致性）
*
* @param key
* @return
*/
public static CacheItem getCacheItem(String key) {
return cache.getCacheItem(key);
}
}
相关推荐
Memcache是一种广泛应用于Web开发中的分布式内存缓存系统，它能有效地缓解数据库的负载，提高网站性能。...为了充分利用这类工具，建议定期检查和分析监控数据，根据实际情况做出相应的调整和优化。
标题中的“自己写的一个php memcache操作类”指的是一个自定义的PHP类，用于与Memcached缓存系统进行交互。Memcached是一种广泛使用的分布式内存对象缓存系统，它能够提高Web应用的性能，通过存储数据在内存中，避免...
JAVA遍历Memcache缓存中所有的KEY的方法，可以直接引入使用。
**Memcached 图形管理工具详解** Memcached 是一款高性能、分布式的内存对象缓存系统，广泛应用于Web应用中，用于减轻数据库的负载，...在日常运维中，合理利用这类工具，对于提升服务质量、降低故障率具有重要意义。
Memcache操作类是PHP中与Memcache进行交互的工具，让我们深入探讨一下如何使用这个类以及它提供的各种功能。 1. **连接Memcache服务器** 在使用Memcache操作类之前，你需要先建立与Memcache服务器的连接。可以使用...
通过上述知识点，我们可以看出，该memcacheQueue类提供了一个在PHP中操作Memcache队列的简单而强大的工具。开发者可以利用这个类的实例来构建高效的数据处理流程，如消息队列、缓存策略等。在使用这个类的时候，...
在Go语言中，工具类是开发者为了方便复用和简化代码而创建的模块，它们通常包含特定功能的函数集合。本篇文章将详细讲解标题和描述中提到的几个关键工具类，包括JSON处理、XML处理、Redis数据库操作、Memcached缓存...
压缩包子文件的文件名称列表中，`memadmin-1.0.8.tar.gz`可能是一个管理Memcache服务器的工具，它可以帮助监控和管理Memcached实例，例如添加、删除和查看缓存项，或者查看服务器状态等。 总的来说，PHP 5.3版本的...
- 安装完扩展后，你可以在PHP代码中通过`memcache`类来使用Memcache服务。例如： ```php $memcache = new Memcache; $memcache->connect('localhost', 11211); // 默认的Memcache服务器端口是11211 $memcache->...
在Windows环境下，监控和调试Memcache可以通过第三方工具实现，如Memcached Manager，它提供了一个直观的图形界面，可以查看连接状态、缓存统计信息以及执行基本的操作。 总结来说，Memcache是一个高效、轻量级的...
总结来说，"MemCache Client端类库"是C++开发者用来与MemCache服务器交互的重要工具。对于VS环境下的开发，适应性和兼容性是关键问题。通过修改和优化，我们可以创建一个定制化的客户端，以满足特定项目的需求，提升...
标题中的“PHP实现的...总的来说，这个PHP实现的memcache环形队列类是一个实用的工具，它结合了memcache的高性能缓存能力和环形队列的数据结构特性，可用于处理需要高效并发读写的场景，如消息队列、任务调度等。
- 首先，你需要在项目中引入相应的JAR文件，可以通过Maven或Gradle等构建工具添加依赖，或者手动将JAR文件添加到项目的类路径中。 - 然后，初始化Memcache客户端，配置服务器地址和端口，如： ```java Memcached...
解决这类问题通常需要查阅官方文档、查找类似问题的解决方案，或者尝试不同版本的Memcache扩展，直到找到一个能与当前PHP版本兼容的版本。 总之，Memcache是一个强大的缓存系统，PHP的Memcache扩展则为PHP开发者...
在PHP代码中，可以使用`Memcache`类来连接到Memcached服务器，创建、读取、更新和删除缓存中的键值对。 例如，以下是一段基本的PHP代码示例，演示如何连接到Memcached服务器并设置一个缓存项： ```php $memcache ...
7. **使用Memcache**：现在你可以使用Memcache类的各种方法来存储和检索数据，如`set()`, `get()`, `delete()`等，以提升应用程序的性能。 请注意，实际操作时可能需要根据你的具体环境进行调整，例如，如果你的...
3. **使用Memcached客户端**：一旦安装完成，可以使用`Memcached`类来与Memcached服务器交互，进行数据存储和检索。 综上所述，`php_memcache.dll`扩展文件集合包是提升PHP应用性能的关键工具，特别是当处理大量...
Visual C++ 14编译器，即Visual Studio 2015，是用来构建php_memcache扩展的工具链，这意味着该扩展是使用这个编译器和对应的运行时库构建的，因此需要确保目标系统上安装了相应的VC++ Redistributable。 压缩包内...
《PHP与Memcache扩展：深入理解...总结，PHP 5.6的Memcache扩展（php_memcache.dll）是提升Web应用性能的重要工具。理解其工作原理，熟练掌握使用方法，并结合最佳实践，可以显著提升PHP应用的响应速度和用户体验。