xmemcached主要用法及与Spring集成--总结

谁践踏了优雅 2022-06-10 08:49 238阅读 0赞

**一、Memcached Client简要介绍**   
Memcached Client目前有3种：

*  [Memcached Client for Java][]
 *  [SpyMemcached][]
 *  [XMemcached][]

这三种Client一直存在各种争议：

*  Memcached Client for Java 比 SpyMemcached更稳定、更早、更广泛；
 *  SpyMemcached 比 Memcached Client for Java更高效；
 *  XMemcached 比 SpyMemcache并发效果更好。

用数据来说话，参考官方性能对比：   
Memcached Client for Java： [https://github.com/gwhalin/Memcached-Java-Client/wiki/PERFORMANCE][https_github.com_gwhalin_Memcached-Java-Client_wiki_PERFORMANCE]    
XMemcached： [http://xmemcached.googlecode.com/svn/trunk/benchmark/benchmark.html][http_xmemcached.googlecode.com_svn_trunk_benchmark_benchmark.html]    
  
**二、XMemcached特性**    
XMemcached特性：

*  高性能
 *  支持完整的memcached文本协议,二进制协议。
 *  支持JMX，可以通过MBean调整性能参数、动态添加/移除server、查看统计等。
 *  支持客户端统计
 *  支持memcached节点的动态增减。
 *  支持memcached分布:余数分布和一致性哈希分布。
 *  更多的性能调整选项。

xMemcached是memcached的一个[Java][]客户端，基于[Java ][Java]nio，支持memcached的所有协议。本文简要介绍xMemcached的基本用法，以及与[spring][]的集成配置。

## `/** * XMemcachedClientBuilder是MemcachedClientBuilder的一个实现类，XMemcachedClient是MemcachedClient的一个实现类； * 在实际使用中，应该使用接口，利用多态特性，这里直接使用实现类，是为了方便查看实现类的源码。 */ /** * MemcachedClientBuilder builder = new XMemcachedClientBuilder(AddrUtil.getAddresses("192.168.56.200:11211")); * MemcachedClient memcachedClient = null; */` ##

## xMemcached的主要方法示例 ##

MemcachedClient 让spring管理，通过xml设置配置，一下是代码配置，下面有和spring的整合

XMemcachedClientBuilder builder = new XMemcachedClientBuilder(AddrUtil.getAddresses("192.168.56.200:11211 192.168.56.200:11212"));
    XMemcachedClient xMemcachedClient = null;
    
    // 注意处理相关异常
    
    // 默认是采用余数哈希，可以修改为一致性哈希
    builder.setSessionLocator(new KetamaMemcachedSessionLocator());
    // 启用二进制协议，getAndTouch等方法仅在二进制协议中支持
    builder.setCommandFactory(new BinaryCommandFactory());
    
    // build the memcached client
    xMemcachedClient = (XMemcachedClient) builder.build();
    
    // set: 第一个参数是key，第二个参数是超时时间，第三个参数是value
    xMemcachedClient.set("first", 0, "tianjin");//添加或者更新
    xMemcachedClient.add("second", 20, "chengdu");//添加,key不存在添加成功返回true,否则返回false
    xMemcachedClient.replace("first", 0, "Beijing");//替换,key已经存在替换成功返回true,不存在返回false
    
    // get：根据key获取value
    String firstValue = xMemcachedClient.get("first");

String firstValue = xMemcachedClient.get("first",100);//100毫秒没有返回，超时

// delete: 删除item
    xMemcachedClient.delete("second");
    xMemcachedClient.deleteWithNoReply("third");
    
    // touch：修改item过期时间
    xMemcachedClient.touch("first", 0);
    firstValue = xMemcachedClient.getAndTouch("first", 10);
    logger.info("getAndTouch op, first value: {}", firstValue);
    
    // append, prepend: 追加数据
    xMemcachedClient.append("first", ", come on");
    xMemcachedClient.prepend("first", "hello ");
    logger.info("append and prepend op, first value: {}", xMemcachedClient.get("first"));
    
    /**
     * cas: 通过gets操作返回GetResponse，其中包括value值和cas值
     */
     GetsResponse<Integer> result = client.gets("a");
      long cas = result.getCas(); 
      //尝试将a的值更新为2
      if (!client.cas("a", 0, 2, cas)) {
        System.err.println("cas error");
       }// cas: 重试更方便；第一个方法表示重试次数，第二个方法表示更新的值

xMemcachedClient.cas("first", 0, new CASOperation<String>() {
        @Override
        public int getMaxTries() {
            return 1;//重试一次
        }
    
        @Override
        public String getNewValue(long currentCAS, String currentValue) {
            return "xian";
        }
    });
    
    // incr/decr: 值的增加减少 incr/decr操作的使用，两个操作类似Java中的原子类如AtomicIntger，用于原子递增或者递减变量数值
    
    xMemcachedClient.incr("id", 3, 0);//自增3，初始值0（默认0）
    xMemcachedClient.incr("id", 5);
    xMemcachedClient.decr("id", 2);//递减最小到0

// namespace: set时指定命名空间，get时也需要指定，可以使命名空间中的所有items失效 String ns = "namespace" ;
    this.memcachedClient.withNamespace(ns,
                    new MemcachedClientCallable<Void>() {
    
                        public Void call(MemcachedClient client)
                                throws MemcachedException, InterruptedException,
                                TimeoutException {
                            //a,b,c都在namespace下
                            client.set("a",1);
                            client.set("b",1);
                            client.set("c",1);
                            return null;
                        }
                    });
    //获取命名空间内的a对应的值
    Integer aValue = memcachedClient.withNamespace(ns,
                    new MemcachedClientCallable<Integer>() {
    
                        public Integer call(MemcachedClient client)
                                throws MemcachedException, InterruptedException,
                                TimeoutException {
                                     return client.get("a");
                        }
                    });
    
    //使得命名空间失效
    memcachedClient.invalidateNamespace(ns);// stats: 获取统计，也可以根据items获取统计Map<InetSocketAddress, Map<String, String>> stats = xMemcachedClient.getStats();for (InetSocketAddress addr: stats.keySet()) {    logger.info("stats map: {}: {}", addr, stats.get(addr).toString());}// flush_all: 是所有item都过期xMemcachedClient.flushAll("192.168.56.200:11211");// 删除一个serverxMemcachedClient.removeServer("192.168.56.200:11212");

##  ##

## xMemcached ##

XMemcached由于是基于nio，因此通讯过程本身是异步的，client发送一个请求给memcached，你是无法确定memcached什么时候返回这个应答，客户端此时只有等待，因此还有个等待超时的概念在这里。客户端在发送请求后，开始等待应答，如果超过一定时间就认为操作失败，**这个等待时间默认是5秒(1.3.8开始改为5秒，之前是1秒）**，上面例子展现的3个方法调用的都是默认的超时时间，这三个方法同样有允许传入超时时间的重载方法，例如

value=client.get(“hello”,3000);

还有不需要等待的方法：通过deleteWithNoReply方法，这个方法删除数据并且告诉memcached不用返回应答，因此这个方法不会等待应答直接返回，特别适合于批量处理；同样地，set、add、replace等方法也有相应的withNoReply重载版本

## xMemcached与Spring集成 ##

> applicationContext.xml的配置：

<beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    
        
        <bean name="server1" class="java.net.InetSocketAddress">
            <constructor-arg><value>localhost</value></constructor-arg>
            <constructor-arg><value>11211</value></constructor-arg>
        </bean>
        
        <bean id="memcachedClientBuilder" class="net.rubyeye.xmemcached.XMemcachedClientBuilder">
            <constructor-arg name="addressList" value="localhost:11211">
            </constructor-arg>  <property name="connectTimeout"><value>3000</value></property>                <property name="authInfoMap">        <map>        <entry key-ref="server1">            <bean class="net.rubyeye.xmemcached.auth.AuthInfo" factory-method="plain">                <constructor-arg name="username"><value>xxx</value></constructor-arg>                <constructor-arg name="password"><value>123</value></constructor-arg>            </bean>        </entry>        </map>        </property>                        <property name="connectionPoolSize" value="2"></property>                <property name="commandFactory">            <bean class="net.rubyeye.xmemcached.command.BinaryCommandFactory"></bean>        </property>                <property name="transcoder">            <bean class="net.rubyeye.xmemcached.transcoders.SerializingTranscoder"></bean>        </property>                <property name="sessionLocator">            <bean class="net.rubyeye.xmemcached.impl.KetamaMemcachedSessionLocator"></bean>        </property>    </bean>        <bean name="memcachedClient" factory-bean="memcachedClientBuilder"          factory-method="build" destroy-method="shutdown">    </bean></beans>

> java[测试][Link 1]类：

MemcachedClient memcachedClient = null;
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    try {
        memcachedClient = (MemcachedClient) applicationContext.getBean("memcachedClient");
        memcachedClient.set("spring", 0, "3.0.0.RELEASE");
        logger.info("spring: {}", memcachedClient.get("spring"));
        memcachedClient.replace("spring", 0, "4.0.0.RELEASE is coming");
        logger.info("spring, {}", memcachedClient.get("spring"));
    } catch (Exception e) {
        logger.info("spring test", e);
    }

遇到的坑：不要每次都使用 XMemcachedClientBuilder.build();创建client,内部应该没有做单例，调用多了就会内存溢出，所以自己实现单例 使用下面的配置应该是spring启动时创建client 
        <bean name="memcachedClient" factory-bean="memcachedClientBuilder"
              factory-method="build" destroy-method="shutdown">
        </bean>
     如果启动时没有创建成功，最简单的，再手动build一次 @Autowired
    private XMemcachedClientBuilder memcachedClientBuilder;
    @Autowired
    private MemcachedClient memcachedClient;
    
    private MemcachedClient createClient() throws Exception{
        if(memcachedClient==null){//如果spring没有创建成功，再build一次
           return memcachedClient = memcachedClientBuilder.build();
        }
        return null;
    } 问题2：默认连接超时connectTimeout 是60000毫秒，如果网络问题连不上服务器，线程会一直请求1分钟，堵塞时间太长，设置连接超时时间 	<property name="connectTimeout"><value>3000</value></property>
    简要总结如下： 
    
       
        
         Memcached的Key，要杜绝使用空格，且长度控制在250个字符。
         Memcached的Value，要控制体积，必须小于1MB，必要时进行使用压缩。
         失效时间，0为永久有效，最大值不得超过30天（2592000s），否则重新计算可能缓存只有1秒
         Memcached仅支持LRU算法，完全适用你的需要。
         尽量不要将List这种重体积对象扔到Memcached中，传输、存储都会产生瓶颈。
         使用一致性哈希算法实现，提高多个Memcacehd Server利用率。
        关于使用XMemcached实现时，参考如下实现： 
    
       
        
        
         Java代码   
        
         private MemcachedClientBuilder createMemcachedClientBuilder(           Properties properties) {       String addresses = properties.getProperty(ADDRESSES).trim();          if (logger.isInfoEnabled()) {           logger.info("Configure Properties:[addresses = " + addresses + "]");       }       MemcachedClientBuilder builder = new XMemcachedClientBuilder(               AddrUtil.getAddresses(addresses));          // 使用二进制文件       builder.setCommandFactory(new BinaryCommandFactory());       // 使用一致性哈希算法（Consistent Hash Strategy）       builder.setSessionLocator(new KetamaMemcachedSessionLocator());       // 使用序列化传输编码       builder.setTranscoder(new SerializingTranscoder());       // 进行数据压缩，大于1KB时进行压缩       builder.getTranscoder().setCompressionThreshold(1024);          return builder;   }   
        
         
       
        
    主要有以下几点参考： 
    
       
        
         使用二进制文件模式
         使用一致性哈希算法
         使用序列化编码
         对数据进行压缩

参考 * https://nkcoder.github.io/2014/02/16/xmemcached-usage-with-spring/ --快速应用 * * https://github.com/killme2008/xmemcached --官方相关链接： （写的非常好）
    Memcached笔记——（一）安装&常规错误&监控 
    Memcached笔记——（二）XMemcached&Spring集成 
    Memcached笔记——（三）Memcached使用总结 
    Memcached笔记——（四）应对高并发攻击

2016-11-16 追加：
    
    1：使用incr原子性 自增发送红包,应对高并发
    2：使用add 作为分布式锁
    坑1：set 设置过期时间如果超过3个月，接口返回成功，其实没有存上

[Memcached Client for Java]: http://code.google.com/p/memcache-client-forjava/
[SpyMemcached]: http://code.google.com/p/spymemcached/
[XMemcached]: http://code.google.com/p/xmemcached/
[https_github.com_gwhalin_Memcached-Java-Client_wiki_PERFORMANCE]: https://github.com/gwhalin/Memcached-Java-Client/wiki/PERFORMANCE
[http_xmemcached.googlecode.com_svn_trunk_benchmark_benchmark.html]: http://xmemcached.googlecode.com/svn/trunk/benchmark/benchmark.html
[Java]: http://lib.csdn.net/base/java
[spring]: http://lib.csdn.net/base/javaee
[Link 1]: http://lib.csdn.net/base/softwaretest