`
Donald_Draper
  • 浏览: 984272 次
社区版块
存档分类
最新评论

Memcache客户端（Xmemcached）

memcached 
阅读更多
memcached 安装配置：http://donald-draper.iteye.com/blog/2395580
memcached 命令：http://donald-draper.iteye.com/blog/2395628
memcache Java客户端有三种方式具体介绍可以参见下面这篇文章：
Memcache的三种Java客户端的对比和选择:http://blog.csdn.net/heiyueya/article/details/64441901
三种方式分别为：
1.官方提供的基于传统阻塞io由Greg Whalin维护的客户端memcached client for java
网址：http://www.whalin.com/memcached
特点： 较早推出的memcached JAVA客户端API，应用广泛，运行比较稳定，使用阻塞IO，不支持CAS操作。
github:https://github.com/gwhalin/Memcached-Java-Client
2.Dustin Sallings实现的基于java nio的Spymemcached
网址：http://code.google.com/p/spymemcached/
最新版本：memcached-2.1.jar
特点： A simple, asynchronous, single-threaded memcached client written in java.
用到了java1.5版本的concurrent和nio，存取速度会高于前者，但是稳定性不好，测试中常报timeOut等相关异常，支持CAS操作。
github:https://github.com/dustin/java-memcached-client
3.XMemcached
XMemcached同样是基于Java NIO的客户端，Java NIO相比于传统阻塞IO模型来说，
有效率高（特别在高并发下）和资源耗费相对较少的优点。传统阻塞IO为了提高效率，
需要创建一定数量的连接形成连接池，而NIO仅需要一个连接即可（当然,NIO也是可以做池化处理），相对来说减少了线程创建和切换的开销，这一点在高并发下特别明显。
因此 XMemcached与Spymemcached在性能都非常优秀，在某些方面（存储的数据比较小的情况下）Xmemcached比
Spymemcached的表现更为优秀。
github:https://github.com/killme2008/xmemcached
我们选择XMemcached来实现Memcache的客户端：
本文的源代码可以从以下地址load:
https://github.com/Donaldhan/memcached-demo

启动memcached： 
[memcached@donald ~]$ memcached -p 11211 -d -u memcached -l 192.168.126.128 -c 1024 
[memcached@donald ~]$ ps -ef | grep memcached
root       4514   1248  0 22:01 ?        00:00:00 sshd: memcached [priv]
memcach+   4517   4514  0 22:01 ?        00:00:00 sshd: memcached@pts/1
memcach+   5172      1  0 22:04 ?        00:00:00 memcached -p 11211 -d -u memcached -l 192.168.126.128 -c 1024
memcach+   5238   4522  0 22:07 pts/1    00:00:00 grep --color=auto memcached
[memcached@donald ~]$


创建memcache属性文件memcached.properties： 
############################
##memcached server ip address list
############standby############## 
standbyServerList=192.168.126.128:11211
poolName=sidsock
poolSize=16


创建属性文件工具类： 
package util;


import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


/**
 * 
 * @author donald
 * 2017年9月29日
 * 下午10:21:34
 */
public class PropertiesUtil {
	private static final Logger log  = LoggerFactory.getLogger(PropertiesUtil.class);
	private static final String MEMCACHED_CONFIG_FILE = "memcached.properties";
    private static volatile PropertiesUtil instance = null;
    private static Properties properties = null;
    static{
    	 if (properties == null) {
    		 properties = new Properties();
         }
         try {
        	 InputStream inputStream = Thread.currentThread().getContextClassLoader()
        	            .getResourceAsStream(MEMCACHED_CONFIG_FILE);
        	 properties.load(inputStream);
         } catch (IOException e1) {
             e1.printStackTrace();
         }
    }
    
    /**
     * 
     * @return
     */
    public static synchronized PropertiesUtil getInstance() {
        if (instance == null) {
        	instance = new PropertiesUtil();
        }
        return instance;
    }
    /**
     * 
     * @param key
     * @return
     */
    public String getProperty(String key) {
        return properties.getProperty(key);
    }
    
    /**
     * 获取属性int值
     * @param key
     * @return
     */
    public Integer getInteger(String key) {
    	String value = properties.getProperty(key);
        return Integer.valueOf(value);
    }
    
    
    public static void main(String[] args) {
		log.info("serverList:"+PropertiesUtil.getInstance().getProperty("standbyServerList"));
	}
}


创建memcache客户端： 
package bootstrap;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.util.List;
import java.util.concurrent.TimeoutException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import net.rubyeye.xmemcached.Counter;
import net.rubyeye.xmemcached.GetsResponse;
import net.rubyeye.xmemcached.MemcachedClient;
import net.rubyeye.xmemcached.MemcachedClientBuilder;
import net.rubyeye.xmemcached.XMemcachedClientBuilder;
import net.rubyeye.xmemcached.exception.MemcachedException;
import net.rubyeye.xmemcached.utils.AddrUtil;
import util.PropertiesUtil;

/**
 * Memcached Standby模式 客户端
 * @author donald
 * 2017年10月10日
 * 下午12:49:45
 */
public class MemcachedStandbyClient {
	private static final Logger log = LoggerFactory.getLogger(MemcachedStandbyClient.class);
	private static final String MEMCACHED_SERVER_LIST = "standbyServerList";
	private static final String MEMCACHED_POOL_SIZE = "poolSize";
	private static PropertiesUtil  propertiesUtil = PropertiesUtil.getInstance();
	private static volatile MemcachedStandbyClient instance;
	private static MemcachedClientBuilder builder;
	private static MemcachedClient memcachedClient;
	static{
		String standbyServerList = propertiesUtil.getProperty(MEMCACHED_SERVER_LIST);
		List<InetSocketAddress> serverAddresses = AddrUtil.getAddresses(standbyServerList);
		builder = new XMemcachedClientBuilder(serverAddresses);
		/**
		 * Xmemcached是基于java nio的client实现，默认对一个memcached节点只有一个连接，
		 * 这在通常情况下已经有非常优异的表现。但是在典型的高并发环境下,nio的单连接也会遇到性能瓶颈。
		 * 因此XMemcached支持设置nio的连接池，允许建立多个连接到同一个memcached节点，
		 * 但是请注意，这些连接之间是不同步的，因此你的应用需要自己保证数据更新的同步，启用连接池可以通过下面代码：
		 */
		
		/*int poolSize = propertiesUtil.getInteger(MEMCACHED_POOL_SIZE);
		builder.setConnectionPoolSize(poolSize);
		*/
		try {
			memcachedClient = builder.build();
		} catch (IOException e) {
			log.error("连接异常");
			e.printStackTrace();
		}
	}
	public static synchronized MemcachedStandbyClient getInstance() {
		if (instance == null) {
			instance = new MemcachedStandbyClient();
		}
		return instance;
	}

	/**
	 * 
	 * @param key
	 * @param value
	 * @return
	 */
	public boolean set(String key,Object value){
		return set(key, 0, value);
	}
	/**
	 * 
	 * @param key
	 * @param expire 过期时间秒
	 * @param value
	 * @return
	 */
	public boolean set(String key,int expire,Object value){
		boolean finish = false;
		try {
			finish = memcachedClient.set(key, expire, value);
		} catch (TimeoutException e) {
			log.error("set超时");
			e.printStackTrace();
		} catch (InterruptedException e) {
			log.error("set中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("set错误");
			e.printStackTrace();
		}
		return finish;
	}
	/**
	 * 
	 * @param key
	 * @param value
	 * @return
	 */
	public boolean add(String key,Object value){
		return add(key, 0, value);
	}
	/**
	 * 
	 * @param key
	 * @param expire 过期时间秒
	 * @param value
	 * @return
	 */
	public boolean add(String key,int expire,Object value){
		boolean finish = false;
		try {
			finish = memcachedClient.add(key, expire, value);
		} catch (TimeoutException e) {
			log.error("add超时");
			e.printStackTrace();
		} catch (InterruptedException e) {
			log.error("add中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("add错误");
			e.printStackTrace();
		}
		return finish;
	}
	/**
	 * 
	 * @param key
	 * @return
	 */
	public Object get(String key){
		Object value = null;
		try {
			value = memcachedClient.get(key);
		} catch (TimeoutException e) {
			log.error("get超时");
			e.printStackTrace();
		} catch (InterruptedException e) {
			log.error("get中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("get操作错误");
			e.printStackTrace();
		}
		return value;
	}
	/**
	 * 
	 * @param key
	 * @param appendValue
	 * @return
	 */
	public boolean append(String key,Object appendValue){
		boolean finish = false;
		try {
			finish = memcachedClient.append(key, appendValue);
		} catch (TimeoutException e) {
			log.error("append超时");
			e.printStackTrace();
		} catch (InterruptedException e) {
			log.error("append中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("append操作错误");
			e.printStackTrace();
		}
		return finish;
	}
	/**
	 * 
	 * @param key
	 * @param prependValue
	 * @return
	 */
	public boolean prepend(String key,Object prependValue){
		boolean finish = false;
		try {
			finish = memcachedClient.prepend(key, prependValue);
		} catch (TimeoutException e) {
			log.error("prepend超时");
			e.printStackTrace();
		} catch (InterruptedException e) {
			log.error("prepend中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("prepend操作错误");
			e.printStackTrace();
		}
		return finish;
	}
	/**
	 * 
	 * @param key
	 * @param value
	 * @return
	 */
	public boolean replace(String key,Object value){
		return replace(key, 0, value);
	}
	/**
	 * 
	 * @param key
	 * @param expire 过期时间秒
	 * @param value
	 * @return
	 */
	public boolean replace(String key,int expire,Object value){
		boolean finish = false;
		try {
			finish = memcachedClient.replace(key, expire, value);
		} catch (TimeoutException e) {
			log.error("replace超时");
			e.printStackTrace();
		} catch (InterruptedException e) {
			log.error("replace中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("replace错误");
			e.printStackTrace();
		}
		return finish;
	}
	/**
	 * 
	 * @param key
	 * @param expire
	 * @return
	 */
	public boolean touch(String key,int expire){
		boolean finish = false;
		try {
			finish = memcachedClient.touch(key, expire);
		} catch (TimeoutException e) {
			log.error("touch超时");
			e.printStackTrace();
		} catch (InterruptedException e) {
			log.error("touch中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("touch操作错误");
			e.printStackTrace();
		}
		return finish;
	}
	/**
	 * @param key
	 * @param step
	 * @param defalut
	 * @return
	 */
	public long incr(String key,long step,long defalut){
		long value = 0;
		try {
			value = memcachedClient.incr(key, step, defalut);
		} catch (TimeoutException e) {
			log.error("incr超时");
			e.printStackTrace();
		} catch (InterruptedException e) {
			log.error("incr中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("incr操作错误");
			e.printStackTrace();
		}
		return value;
	}
	/**
	 * 
	 * @param key
	 * @param step
	 * @return
	 */
	public long incr(String key,long step){
		long value = 0;
		try {
			value = memcachedClient.incr(key, step);
		} catch (TimeoutException e) {
			log.error("incr超时");
			e.printStackTrace();
		} catch (InterruptedException e) {
			log.error("incr中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("incr操作错误");
			e.printStackTrace();
		}
		return value;
	}
	/**
	 * 
	 * @param key
	 * @param step
	 * @return
	 */
	public long decr(String key,long step){
		long value = 0;
		try {
			value = memcachedClient.decr(key, step);
		} catch (TimeoutException e) {
			log.error("decr超时");
			e.printStackTrace();
		} catch (InterruptedException e) {
			log.error("decr中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("decr操作错误");
			e.printStackTrace();
		}
		return value;
	}
	/**
	 * 
	 * @param key
	 * @return
	 */
	public long gets(String key){
		long sid = 0;
		try {
			GetsResponse<Integer> result = memcachedClient.gets(key);
			sid = result.getCas(); 
		} catch (TimeoutException e) {
			log.error("gets超时");
			e.printStackTrace();
		} catch (InterruptedException e) {
			log.error("gets中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("gets操作错误");
			e.printStackTrace();
		}
		return sid;
	}
	/**
	 * 
	 * @param key
	 * @param obj
	 * @return
	 */
	public boolean cas(String key,Object obj){
		boolean finish = false;
		long sid = gets(key);
		finish = cas(key, 0, obj, sid);
		return finish;
	}
	/**
	 * 
	 * @param key
	 * @param expire
	 * @param obj
	 * @param sid key当前版本id
	 * @return
	 */
	public boolean cas(String key, int expire, Object obj, long sid){
		boolean finish = false;
		try {
			finish = memcachedClient.cas(key, expire, obj, sid);
		} catch (TimeoutException e) {
			log.error("cas超时");
			e.printStackTrace();
		} catch (InterruptedException e) {
			log.error("cas中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("cas操作错误");
			e.printStackTrace();
		}
		return finish;
	}
	/**
	 * @param key
	 * @return
	 */
	public boolean delete(String key){
		boolean finish = false;
		try {
			finish = memcachedClient.delete(key);
		} catch (TimeoutException e) {
			log.error("delete超时");
			e.printStackTrace();
		} catch (InterruptedException e) {
			log.error("delete中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("delete操作错误");
			e.printStackTrace();
		}
		return finish;
	}
	/**
	 * 
	 * @param key
	 * @return
	 */
	public void deleteWithNoReply(String key){
		try {
			memcachedClient.deleteWithNoReply(key);
		} catch (InterruptedException e) {
			log.error("deleteWithNoReply中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("deleteWithNoReply操作错误");
			e.printStackTrace();
		}
	}
	/**
	 * @param key
	 * @return
	 */
	public Counter getCounter(String key) {
		return getCounter(key,0);
	}
	/**
	 * @param key
	 * @param init
	 * @return
	 */
	public Counter getCounter(String key,int init) {
		Counter counter = memcachedClient.getCounter(key,init);
		return counter;
	}
	/**
	 * 
	 */
	public void flushAll(){
		try {
			memcachedClient.flushAll();
		} catch (TimeoutException e) {
			log.error("flushAll超时");
			e.printStackTrace();
		} catch (InterruptedException e) {
			log.error("flushAll中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("flushAll操作错误");
			e.printStackTrace();
		}
	}
	public void shutdown(){
		try {
			memcachedClient.shutdown();
		} catch (IOException e) {
			log.error("客户端关闭异常");
			e.printStackTrace();
		}
	}
	/* (non-Javadoc)
	 * @see java.lang.Object#finalize()
	 */
	@Override
	protected void finalize() {
		try {
			
			memcachedClient.shutdown();
		} catch (IOException e) {
			log.error("memcached 关闭客户端连接失败！");
			e.printStackTrace();
		}
	}

	
}

创建测试类： 
package bootstrap;

import java.util.concurrent.TimeoutException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import net.rubyeye.xmemcached.Counter;
import net.rubyeye.xmemcached.exception.MemcachedException;

/**
 * Memcached Standby模式 客户端测试类
 * @author 
 * donald 
 * 2017年10月10日 
 * 下午12:49:45
 */
public class MemcachedStandbyClientTest {
	private static final Logger log = LoggerFactory.getLogger(MemcachedStandbyClientTest.class);
	public static void main(String[] args) {
		MemcachedStandbyClient memcachedClient = MemcachedStandbyClient.getInstance();
		memcachedClient.set("name", 0, "donald");
		String value = (String) memcachedClient.get("name");
		log.info("set name={}", value);
		memcachedClient.delete("name");
		value = (String) memcachedClient.get("name");
		log.info("delete name={}", value);
		if (!memcachedClient.set("name", 0, "jamel")) {
			log.error("set error");
		}
		value = (String) memcachedClient.get("name");
		log.info("set name={}", value);
		if (memcachedClient.add("name", 0, "donald")) {
			log.error("Add error,key is existed");
		}
		value = (String) memcachedClient.get("name");
		log.info("name={}", value);
		if (!memcachedClient.replace("name", 0, "rain")) {
			log.error("replace error");
		}
		value = (String) memcachedClient.get("name");
		log.info("repalce name={}", value);
		memcachedClient.append("name", "-han");
		value = (String) memcachedClient.get("name");
		log.info("append name={}", value);
		memcachedClient.prepend("name", "0-");
		value = (String) memcachedClient.get("name");
		log.info("prepend name={}", value);
		memcachedClient.touch("name", 3);
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		value = (String) memcachedClient.get("name");
		log.info("after touch name={}", value);
		memcachedClient.deleteWithNoReply("name");
		memcachedClient.set("age", 0, "27");
		log.info("age={}", memcachedClient.get("age"));
		memcachedClient.incr("age", 2, 1);// age 增加2，age不存在，则为1
		memcachedClient.incr("age", 1);
		log.info("incr age={}", memcachedClient.get("age"));
		memcachedClient.decr("age", 2);
		log.info("decr age={}", memcachedClient.get("age"));
		if (!memcachedClient.cas("age", 27)) {
			log.error("cas error");
		}
		log.info("cas age={}", memcachedClient.get("age"));
		Counter counter = memcachedClient.getCounter("counter", 0);
		try {
			log.info("incrementAndGet counter,{}", counter.incrementAndGet());
			log.info("decrementAndGet counter,{}", counter.decrementAndGet());
			log.info("addAndGet counter,{}", counter.addAndGet(3));
		} catch (MemcachedException e) {
			e.printStackTrace();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (TimeoutException e) {
			e.printStackTrace();
		}
		memcachedClient.flushAll();
		memcachedClient.shutdown();
	}
}

运行测试类，控制台输出如下： 
22:20:09.815 [main] INFO  net.rubyeye.xmemcached.XMemcachedClient 729- XMemcachedClient is using Text protocol
22:20:09.859 [main] INFO  com.google.code.yanf4j.nio.impl.SelectorManager 37- Creating 4 reactors...
22:20:09.876 [main] INFO  com.google.code.yanf4j.core.impl.AbstractController 377- The Controller started at localhost/127.0.0.1:0 ...
22:20:18.928 [Xmemcached-Reactor-0] INFO  com.google.code.yanf4j.core.impl.AbstractController 253- Add a session: 192.168.126.128:11211
22:20:18.963 [main] INFO  bootstrap.MemcachedStandbyClientTest 24- set name=donald
22:20:18.973 [main] INFO  bootstrap.MemcachedStandbyClientTest 27- delete name=null
22:20:18.978 [main] INFO  bootstrap.MemcachedStandbyClientTest 32- set name=jamel
22:20:18.983 [main] INFO  bootstrap.MemcachedStandbyClientTest 37- name=jamel
22:20:18.989 [main] INFO  bootstrap.MemcachedStandbyClientTest 42- repalce name=rain
22:20:18.995 [main] INFO  bootstrap.MemcachedStandbyClientTest 45- append name=rain-han
22:20:19.004 [main] INFO  bootstrap.MemcachedStandbyClientTest 48- prepend name=0-rain-han
22:20:22.012 [main] INFO  bootstrap.MemcachedStandbyClientTest 56- after touch name=null
22:20:22.017 [main] INFO  bootstrap.MemcachedStandbyClientTest 59- age=27
22:20:22.026 [main] INFO  bootstrap.MemcachedStandbyClientTest 62- incr age=30
22:20:22.031 [main] INFO  bootstrap.MemcachedStandbyClientTest 64- decr age=28
22:20:22.043 [main] INFO  bootstrap.MemcachedStandbyClientTest 68- cas age=27
22:20:22.050 [main] INFO  bootstrap.MemcachedStandbyClientTest 71- incrementAndGet counter,1
22:20:22.053 [main] INFO  bootstrap.MemcachedStandbyClientTest 72- decrementAndGet counter,0
22:20:22.055 [main] INFO  bootstrap.MemcachedStandbyClientTest 73- addAndGet counter,3
22:20:22.089 [main] INFO  com.google.code.yanf4j.core.impl.AbstractController 486- Controller has been stopped.
22:20:22.089 [Xmemcached-Reactor-2] INFO  com.google.code.yanf4j.core.impl.AbstractController 368- Remove a session: 192.168.126.128:11211
0
顶
0
踩
分享到：
| jdcb查询SQL Server数据乱码问题解决方法
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    memCache源码java客户端

    Java社区提供了多种memCache客户端，如spymemcached、xmemcached、memcached-client等。其中，spymemcached是较常用的一款，它由Danga Interactive开发并开源，具有简单易用、性能稳定的特点。 ### 二、...

    memcache实现java客户端

    1. **Java Memcache客户端库**：在Java中，常用的Memcache客户端库有Xmemcached和spymemcached。这些库提供了丰富的API，使Java开发者能够方便地将数据存储到Memcache服务器。 2. **Xmemcached**：这是一个功能强大...

    memcache.spymemcached，和xmemcached 三种缓存实例

    本文将深入探讨memcache的三种常见Java客户端实现：spymemcached、xmemcached和原生的memcache接口。 1. **spymemcached**： spymemcached是由Spy公司开发的一个开源Java客户端，它是Memcached最常用的Java库之一...

    memcache所需要的jar包

    - Xmemcached是流行的Java Memcache客户端之一，它提供了高并发、低延迟的性能，且支持多线程和NIO。 - 使用Xmemcached，开发者可以通过简单的API调用来执行诸如设置、获取、删除缓存项等操作。 4. **...

    java调用memcache简单实例

    介绍：memcache缓存的一个项目。只是简单的增删盖查。 使用前，应该先安装...memcache客户端：xmemcached-2.0.0.jar 这里又加入了很多spring的jar包，是应为TestSpringMemcache.java中把memcache整合到spring中。

    Memcache Session Manager Tomcat8.5.6

    6. **Java Memcache客户端**: 集成Memcache到Java应用中通常需要一个客户端库，如spymemcached或Xmemcached，这些库提供了与Memcache服务器通信的API。 7. **jar包**: Java Archive (JAR) 文件是Java平台上的归档...

    memcache jar

    - Java中常用的Memcache客户端库有spymemcached和Xmemcached等，这些库提供了与Memcache服务器通信的API。 - JAR文件包含了这些客户端库的实现，例如`spymemcached.jar`或`xmemcached.jar`，它们包含必要的类和...

    memcache共享session用到的jar

    这个压缩包"memcache共享session用到的jar"包含的是已经经过测试，兼容的Memcache客户端库和其他可能需要的依赖。使用这个包可以避免因版本不兼容导致的问题，直接集成到项目中即可开始使用Memcache进行session共享...

    5.1 Memcache部署和使用-带书签-201809301

    Memcache客户端库广泛存在于多种编程语言中，包括Perl、PHP、Python、Ruby、C#、C/C++、Lua等。 ### 2.0 单机部署 在 CentOS 6.6 x64 上部署Memcache的步骤如下： 1. **规划**：确定OS、IP地址、Memcache版本、...

    demo_memcache_ieda

    "demo_memcache_ieda"项目是一个很好的学习资源，通过对比spymemcached和XMemcached这两个客户端，开发者可以了解如何在Java项目中集成并使用Memcached，从而优化应用性能，实现高效的数据缓存。

    征服 Kestrel + XMemcached

    Kestrel是一个高性能、异步的分布式消息队列，而XMemcached则是一个广泛使用的Java客户端，用于连接到Memcached缓存服务器。在这里，我们将会探讨这两个技术的基本概念、它们在IT领域的应用以及如何将它们结合使用。...

    Java开发中的Memcache原理及实现

    - 客户端库：Java开发者常用的Memcached客户端库有spymemcached、xmemcached、smemcached等。它们提供了API接口，使得Java应用能够轻松地操作Memcached。 - 连接管理：客户端库负责与Memcached服务器建立连接，...

    memcache-demo

    标题"memcache-demo"指的是一个关于Memcache的示例项目，其中可能包含如何在Java环境中，特别是在使用XMemcached这个客户端库时，集成和使用Memcache的代码实例。XMemcached是一个高效、稳定的Java Memcached客户端...

    xmemcached：高性能，易于使用的Java多线程memcached客户端

    介绍XMemcached是Java中的一种高性能，易于使用的阻塞多线程memcached客户端。 它是基于nio的，并且经过了精心设计，以实现最佳性能。快速开始：有助于源代码并将其签出到本地计算机。 进行更改并创建拉取请求。 ...

    memcached客户端

    6. **Go** - `go-memcache`：Go语言的 `go-memcache` 客户端库简单易用，提供了基本的Memcached操作，适合快速集成到Go项目中。 7. **C++** - `libmemcached`：这是一个跨平台的C++库，不仅提供客户端功能，还包含...

    JAVA的memcache服务器安装以及相关最新jar包

    总结以上内容，本文档主要涵盖了在Java环境下安装和使用Memcached服务器的步骤，以及如何利用Java客户端库（如spymemcached和xmemcached）进行数据存取操作。这些知识点对于开发高并发、高性能的Web应用非常有用。

    memcached java client

    本篇文章将详细介绍两个常用的Java Memcached客户端：xmemcached和memcache-client-forjava。 **1. xmemcached** xmemcached是由Ketoo开发的一个高性能、高可用性的Java Memcached客户端。它提供了丰富的API，支持...

    memcache学习资料（包含memcache和java_memcache相应的jar）

    `java_memcache`相关的JAR文件通常包含了Java Memcached客户端库，如Xmemcached或spymemcached，这些库提供了API，让Java开发者能够方便地在Java应用中集成和使用Memcached服务。 在Windows环境下部署和使用...

    java memcache使用例子

    常见的Java Memcached客户端库有spymemcached和xmemcached。这里以spymemcached为例，因为其简单易用和广泛支持。 1. 添加依赖 在你的项目中，你需要引入spymemcached的依赖。如果你使用的是Maven，添加以下依赖到...

Magicbox
Global site tag (gtag.js) - Google Analytics