Python写入Memcached但Java读不到—flags是何方神圣 | 窗纸儿吧

# 1.安装libevent库
yum install libevent libevent-devel  
# 2.下载最新版本
wget http://memcached.org/latest
# 3.解压源码
tar -zxvf memcached-1.x.x.tar.gz 
# 4.进入目录
cd memcached-1.x.x 
# 5.配置
./configure --prefix=/usr/local/memcached     
# 6.编译
make
# 7.安装
sudo make install
# 8.启动
/usr/local/memcached/bin/memcached -d -u root
# 9.测试连接
telnet 192.168.37.131 11211
# 命令行响应如下内容则说明连接正常
# Trying 192.168.37.131...
# Connected to 192.168.37.131.
# Escape character is '^]'.

pip install python-memcached==1.53

# write-into-memcache-opration.py
import memcache

mc = memcache.Client(['192.168.37.131:11211'],debug=1)
mc.set("site","blog.chuangzhi8.com") # Python向Memcached写入key为site的值
site = mc.get("site") # 从Memcached读取已经写入的内容
print(site) # 打印读取内容

<dependency>
	<groupId>com.whalin</groupId>
	<artifactId>Memcached-Java-Client</artifactId>
	<version>3.0.2</version>
</dependency>

// MemcachedJavaClientTest.java
package com.haozi.demo;

import com.whalin.MemCached.MemCachedClient;
import com.whalin.MemCached.SockIOPool;

public class MemcachedJavaClientTest {
	/**
	 * 此方法主要演示使用Memcached-Java-Client Java客户端从Memcached读取数据
	 * 
	 */
	public static void main(String[] args) { 
		//initialize the SockIOPool that maintains the Memcached Server Connection Pool 
		String[] servers = { "192.168.37.131:11211" };
		SockIOPool pool = SockIOPool.getInstance("Test1");
		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(); 
		//Get the Memcached Client from SockIOPool named Test1 
		MemCachedClient mcc = new MemCachedClient("Test1");
		System.out.println(mcc.get("site"));// 从Memcached读取Python写入的key为site的值

}
}

python write-into-memcache-opration.py

# 编译
javac MemcachedJavaClientTest.java
# 执行
java MemcachedJavaClientTest

# 在set()方法中主要调用了 _val_to_store_info(self, val, min_compress_len)方法将即将存储到Memcached中的数据进行转换并生成对应的flags值
# @see /usr/lib/python2.7/site-packages/memcache.py
def _val_to_store_info(self, val, min_compress_len):
    """
       Transform val to a storable representation, returning a tuple of the flags, the length of the new value, and the new value itself.
    """
    flags = 0 # 默认为0即对应字符串的flags值
    if isinstance(val, str):
        pass
    elif isinstance(val, int): ##
        flags |= Client._FLAG_INTEGER
        val = "%d" % val
        # force no attempt to compress this silly string.
        min_compress_len = 0
    elif isinstance(val, long):
        flags |= Client._FLAG_LONG
        val = "%d" % val
        # force no attempt to compress this silly string.
        min_compress_len = 0
    else:
        flags |= Client._FLAG_PICKLE
        file = StringIO()
        if self.picklerIsKeyword:
            pickler = self.pickler(file, protocol = self.pickleProtocol)
        else:
            pickler = self.pickler(file, self.pickleProtocol)
        if self.persistent_id:
            pickler.persistent_id = self.persistent_id
        pickler.dump(val)
        val = file.getvalue()

lv = len(val)
    # We should try to compress if min_compress_len > 0 and we could
    # import zlib and this string is longer than our min threshold.
    if min_compress_len and _supports_compress and lv > min_compress_len:
        comp_val = compress(val)
        # Only retain the result if the compression result is smaller
        # than the original.
        if len(comp_val) < lv:
            flags |= Client._FLAG_COMPRESSED
            val = comp_val

#  silently do not store if value length exceeds maximum

// @see com.schooner.MemCached.AscIIClient.java
private Object get(String cmd, String key, Integer hashCode, boolean asString) {
    // ...... 
    // get SockIO obj using cache key
    // ......

// get result code
    // ......
    // Then analysis the return metadata from server,including key, 
    // ......
    /*
    * Critical block to parse the response header.
    */
    // ......
    Object o = null;
    // we can only take out serialized objects(开始反序列化读取到的数据)
    if (dataSize > 0) {
        if (NativeHandler.isHandled(flag)) {
            byte[] buf = input.getBuffer();
            if ((flag & F_COMPRESSED) == F_COMPRESSED) {
                GZIPInputStream gzi = new GZIPInputStream(new ByteArrayInputStream(buf));
                ByteArrayOutputStream bos = new ByteArrayOutputStream(buf.length);
                int count;
                byte[] tmp = new byte[2048];
                while ((count = gzi.read(tmp)) != -1) {
                    bos.write(tmp, 0, count);
                }
                // store uncompressed back to buffer
                buf = bos.toByteArray();
                gzi.close();
            }
            if (primitiveAsString || asString) {// 明确指定按字符串处理，则直接反序列化为字符串
                o = new String(buf, defaultEncoding);
            } else
                // decoding object
                o = NativeHandler.decode(buf, flag);//根据flag解析读取到的数据（即反序列化）
        } else if (transCoder != null) {
            InputStream in = input;
            if ((flag & F_COMPRESSED) == F_COMPRESSED)
                in = new GZIPInputStream(in);
            // decode object with default transcoder.
            o = transCoder.decode(in);
        }
    }
    return o;

}

// @see com.schooner.MemCached.NativeHandler.java
/**
 * Decodes byte array using memcache flag to determine type.
 * 使用Memcached flag对字节数组解码以确定数据类型
 * @param b
 * @param marker
 * @return
 * @throws UnsupportedEncodingException
 */
public static Object decode(byte[] b, int flag) throws UnsupportedEncodingException {

if (b.length < 1)
		return null;

if ((flag & MemCachedClient.MARKER_BYTE) == MemCachedClient.MARKER_BYTE) //flag=1时表示字节类型
		return decodeByte(b);

if ((flag & MemCachedClient.MARKER_BOOLEAN) == MemCachedClient.MARKER_BOOLEAN) //flag=8192时表示布尔类型
		return decodeBoolean(b);

if ((flag & MemCachedClient.MARKER_INTEGER) == MemCachedClient.MARKER_INTEGER) //flag=4时表示整类型
		return decodeInteger(b);

if ((flag & MemCachedClient.MARKER_LONG) == MemCachedClient.MARKER_LONG) //flag=16384时表示Long类型
		return decodeLong(b);

if ((flag & MemCachedClient.MARKER_CHARACTER) == MemCachedClient.MARKER_CHARACTER) //flag=16时表示字符类型
		return decodeCharacter(b);

if ((flag & MemCachedClient.MARKER_STRING) == MemCachedClient.MARKER_STRING) //flag=32时表示字符串类型
		return decodeString(b);

if ((flag & MemCachedClient.MARKER_STRINGBUFFER) == MemCachedClient.MARKER_STRINGBUFFER) //flag=64时表示StringBuffer类型
		return decodeStringBuffer(b);

if ((flag & MemCachedClient.MARKER_FLOAT) == MemCachedClient.MARKER_FLOAT) //flag=128时表示float类型
		return decodeFloat(b);

if ((flag & MemCachedClient.MARKER_SHORT) == MemCachedClient.MARKER_SHORT) //flag=256时表示short类型
		return decodeShort(b);

if ((flag & MemCachedClient.MARKER_DOUBLE) == MemCachedClient.MARKER_DOUBLE) //flag=512时表示double类型
		return decodeDouble(b);

if ((flag & MemCachedClient.MARKER_DATE) == MemCachedClient.MARKER_DATE) //flag=1024时表示日期类型
		return decodeDate(b);

if ((flag & MemCachedClient.MARKER_STRINGBUILDER) == MemCachedClient.MARKER_STRINGBUILDER) //flag=2048时表示StringBuilder类型
		return decodeStringBuilder(b);

if ((flag & MemCachedClient.MARKER_BYTEARR) == MemCachedClient.MARKER_BYTEARR) //flag=4096时表示字节数组类型
		return decodeByteArr(b);

return null;
}

# memcache.py是修改后的Python源码，memcache.py.bak是原始文件。(为了保证上面复现问题用到的Python代码不修改仍能使用，此处将python读取时用的flags一并改成32)
[root@centos7-1 ~]# diff /usr/lib/python2.7/site-packages/memcache.py /usr/lib/python2.7/site-packages/memcache.py.bak
760c760
<         flags = 32
---
>         flags = 0
1014c1014
<         if  flags == 32 or flags == Client._FLAG_COMPRESSED:
---
>         if  flags == 0 or flags == Client._FLAG_COMPRESSED: