memcache append 大数据 大字符串 压缩

最新推荐文章于 2024-09-12 06:03:56 发布
最新推荐文章于 2024-09-12 06:03:56 发布
阅读量1.4k 收藏
点赞数
分类专栏： Java 文章标签： memcache append 大数据 大字符串 压缩
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/collonn/article/details/51891779
版权

关于MemcacheClient中CachedData.flag的说明
0000000000000010==COMPRESSED==2
0000000000000001==SERIALIZED==1
0000000100000000==SPECIAL_BOOLEAN==256
0000001000000000==SPECIAL_INT==512
0000001100000000==SPECIAL_LONG==768
0000010000000000==SPECIAL_DATE==1024
0000010100000000==SPECIAL_BYTE==1280
0000011000000000==SPECIAL_FLOAT==1536
0000011100000000==SPECIAL_DOUBLE==1792
0000100000000000==SPECIAL_BYTEARRAY==2048
0000100100000000==SPECIAL_X_COMPRESSED==2304
1111111100000000==SPECIAL_MASK==65280
从以上二进制可以看出，这个flag分成了高8位与低8位，这两部分各有含意。
低8位，用来实现   "业务含意叠加" 的效果
高8位，用来表示其它普通的状态， 共可表示256种状态。

先看一个典型的encode过程，先序列化，再压缩
int flag = 0;//初始化
flag |= SERIALIZED;//flag=1, 二进制，01
flag |= COMPRESSED;//flag=3, 二进制，11
经过这2步后，flag就饱含了2种意思
从右数，第1位是1，表示是SERIALIZED，
从右数，第2位是1,表示是COMPRESSED，
从右数，第1位和第2位，一直到第8位，都是特殊的标识位。
如果想要用这个flag实现 "业务含意叠加" 的效果，flag只能取
1,10,100,1000,10000,100000,1000000,10000000，共8个值，即低8位，每位一个值

再看decode过程
int flag = 3//二进制，11
(flags & COMPRESSED) = 1;//说明是压缩数据，其实比较的是从右数第2个标识位是不是1，其它位是不是0
flags = flags & SPECIAL_MASK;//这一行的作用是抹去低8位(特殊的标识位)
再去判断是什么类型就可以正确的用switch了，比较的是高8位。

============================================= 分隔线 =============================================

我们都知道，memcache性能还是相当不错的，而且还可以设置是否启用压缩。

对于set方法，如果超过压缩阀值，会启用压缩，这没问题。

对于append方法，如果超过压缩阀值，同样会启用压缩，但问题来了，append的数据会有2种不同的类型，一种是启用压缩的，一种是未启用压缩的，那么解压缩时，就会出错了。

好，知道问题原因了，那就fix它。我们知道不管是set还是append，memcache最终存储的数据都是byte1[]，我用自定义一种byte2[]，与byte1[] 不同的是，我们在byte1[]前面加了两种信息，一种信息是该byte1[]有没有进行压缩，第二种信息是byte1[]的长度，最终把byte2[]存储到memcache。解压时，反向解压即可。


只需要重新定义一下Transcoder和一个自定义类即可。

XCompress.java

package com.collonn.javaUtilMvn.memcache.transcoder;

import java.nio.charset.Charset;

/**
 * Created by jelly on 2016-7-8.
 */
public class XCompress {
    private byte[] bytes;

    public XCompress(String str){
        this.bytes = str.getBytes(Charset.forName("UTF-8"));
    }

    public XCompress(String str, String charSetName){
        this.bytes = str.getBytes(Charset.forName(charSetName));
    }

    public XCompress(byte[] bytes){
        this.bytes = bytes;
    }

    public byte[] getBytes() {
        return bytes;
    }

    public void setBytes(byte[] bytes) {
        this.bytes = bytes;
    }
}



Transcoder for net.rubyeye.xmemcached.MemcachedClient

package com.collonn.javaUtilMvn.memcache.transcoder;

import net.rubyeye.xmemcached.transcoders.BaseSerializingTranscoder;
import net.rubyeye.xmemcached.transcoders.CachedData;
import net.rubyeye.xmemcached.transcoders.Transcoder;
import net.rubyeye.xmemcached.transcoders.TranscoderUtils;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.Date;

/**
 * Transcoder that serializes and compresses objects.
 */
public class XTranscoder extends BaseSerializingTranscoder implements
        Transcoder<Object> {

    public void setPackZeros(boolean packZeros) {
        this.transcoderUtils.setPackZeros(packZeros);

    }

    public void setPrimitiveAsString(boolean primitiveAsString) {
        this.primitiveAsString = primitiveAsString;
    }

    private final int maxSize;

    private boolean primitiveAsString;

    public final int getMaxSize() {
        return this.maxSize;
    }

    // General flags
    public static final int SERIALIZED = 1;
    public static final int COMPRESSED = 2;

    // Special flags for specially handled types.
    public static final int SPECIAL_MASK = 0xff00;
    public static final int SPECIAL_BOOLEAN = (1 << 8);
    public static final int SPECIAL_INT = (2 << 8);
    public static final int SPECIAL_LONG = (3 << 8);
    public static final int SPECIAL_DATE = (4 << 8);
    public static final int SPECIAL_BYTE = (5 << 8);
    public static final int SPECIAL_FLOAT = (6 << 8);
    public static final int SPECIAL_DOUBLE = (7 << 8);
    public static final int SPECIAL_BYTEARRAY = (8 << 8);
    public static final int SPECIAL_XCOMPRESSED = (9 << 8);

    private final TranscoderUtils transcoderUtils = new TranscoderUtils(true);

    public TranscoderUtils getTranscoderUtils() {
        return transcoderUtils;
    }

    /**
     * Get a serializing transcoder with the default max data size.
     */
    public XTranscoder() {
        this(CachedData.MAX_SIZE);
    }

    /**
     * Get a serializing transcoder that specifies the max data size.
     */
    public XTranscoder(int max) {
        this.maxSize = max;
    }

    public boolean isPackZeros() {
        return this.transcoderUtils.isPackZeros();
    }

    public boolean isPrimitiveAsString() {
        return this.primitiveAsString;
    }

    /*
     * (non-Javadoc)
     *
     * @see net.spy.memcached.Transcoder#decode(net.spy.memcached.CachedData)
     */
    public final Object decode(CachedData d) {
        byte[] data = d.getData();

        int flags = d.getFlag();
        if ((flags & COMPRESSED) != 0) {
            data = decompress(d.getData());
        }
        flags = flags & SPECIAL_MASK;
        return decode0(d,data, flags);
    }

    protected final Object decodeXCompress(byte[] data) {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        String str = null;

        try {
            int nextIdx = 0;
            int total = data.length;
            while (nextIdx < total) {
                byte compressedByte = data[nextIdx];

                int length = fromBytes(data[nextIdx + 1], data[nextIdx + 2], data[nextIdx + 3], data[nextIdx + 4]);
                byte[] dataBlock = Arrays.copyOfRange(data, nextIdx + 5, nextIdx + 5 + length);
                if (compressedByte == 1) {
                    dataBlock = decompress(dataBlock);
                }

                byteArrayOutputStream.write(dataBlock);
                nextIdx += (1 + 4 + length);
            }

            byte[] deCompressData = byteArrayOutputStream.toByteArray();
            str = decodeString(deCompressData);
        }catch (Exception e){
            log.error("deCompress XCompress error", e);
        }finally {
            try {
                byteArrayOutputStream.close();
            } catch (IOException e) {

            }
        }

        return str;
    }

    protected final Object decode0(CachedData cachedData,byte[] data, int flags) {
        Object rv = null;
        if ((cachedData.getFlag() & SERIALIZED) != 0 && data != null) {
            rv = deserialize(data);
        } else {
            if (this.primitiveAsString) {
                if (flags == 0) {
                    return decodeString(data);
                }
            }
            if (flags != 0 && data != null) {
                switch (flags) {
                    case SPECIAL_BOOLEAN:
                        rv = Boolean.valueOf(this.transcoderUtils
                                .decodeBoolean(data));
                        break;
                    case SPECIAL_INT:
                        rv = Integer.valueOf(this.transcoderUtils.decodeInt(data));
                        break;
                    case SPECIAL_LONG:
                        rv = Long.valueOf(this.transcoderUtils.decodeLong(data));
                        break;
                    case SPECIAL_BYTE:
                        rv = Byte.valueOf(this.transcoderUtils.decodeByte(data));
                        break;
                    case SPECIAL_FLOAT:
                        rv = new Float(Float.intBitsToFloat(this.transcoderUtils
                                .decodeInt(data)));
                        break;
                    case SPECIAL_DOUBLE:
                        rv = new Double(Double
                                .longBitsToDouble(this.transcoderUtils
                                        .decodeLong(data)));
                        break;
                    case SPECIAL_DATE:
                        rv = new Date(this.transcoderUtils.decodeLong(data));
                        break;
                    case SPECIAL_BYTEARRAY:
                        rv = data;
                        break;
                    case SPECIAL_XCOMPRESSED:
                        rv = decodeXCompress(data);
                        break;
                    default:
                        log
                                .warn(String.format("Undecodeable with flags %x",
                                        flags));
                }
            } else {
                rv = decodeString(data);
            }
        }
        return rv;
    }

    /*
     * (non-Javadoc)
     *
     * @see net.spy.memcached.Transcoder#encode(java.lang.Object)
     */
    public final CachedData encode(Object o) {
        byte[] b = null;
        int flags = 0;

        if (o instanceof String) {
            b = encodeString((String) o);
        } else if (o instanceof Long) {
            if (this.primitiveAsString) {
                b = encodeString(o.toString());
            } else {
                b = this.transcoderUtils.encodeLong((Long) o);
            }
            flags |= SPECIAL_LONG;
        } else if (o instanceof Integer) {
            if (this.primitiveAsString) {
                b = encodeString(o.toString());
            } else {
                b = this.transcoderUtils.encodeInt((Integer) o);
            }
            flags |= SPECIAL_INT;
        } else if (o instanceof Boolean) {
            if (this.primitiveAsString) {
                b = encodeString(o.toString());
            } else {
                b = this.transcoderUtils.encodeBoolean((Boolean) o);
            }
            flags |= SPECIAL_BOOLEAN;
        } else if (o instanceof Date) {
            b = this.transcoderUtils.encodeLong(((Date) o).getTime());
            flags |= SPECIAL_DATE;
        } else if (o instanceof Byte) {
            if (this.primitiveAsString) {
                b = encodeString(o.toString());
            } else {
                b = this.transcoderUtils.encodeByte((Byte) o);
            }
            flags |= SPECIAL_BYTE;
        } else if (o instanceof Float) {
            if (this.primitiveAsString) {
                b = encodeString(o.toString());
            } else {
                b = this.transcoderUtils.encodeInt(Float
                        .floatToRawIntBits((Float) o));
            }
            flags |= SPECIAL_FLOAT;
        } else if (o instanceof Double) {
            if (this.primitiveAsString) {
                b = encodeString(o.toString());
            } else {
                b = this.transcoderUtils.encodeLong(Double
                        .doubleToRawLongBits((Double) o));
            }
            flags |= SPECIAL_DOUBLE;
        } else if (o instanceof byte[]) {
            b = (byte[]) o;
            flags |= SPECIAL_BYTEARRAY;
        } else {
            if(!(o instanceof XCompress)){
                b = serialize(o);
                flags |= SERIALIZED;
            }
        }

        assert b != null;
        if (this.primitiveAsString) {
            // It is not be SERIALIZED,so change it to string type
            if ((flags & SERIALIZED) == 0) {
                flags = 0;
            }
        }

        if(o instanceof XCompress){
            flags = SPECIAL_XCOMPRESSED;
            b = processXCompress((XCompress)o);
        }else{
            if (b.length > this.compressionThreshold) {
                byte[] compressed = compress(b);
                if (compressed.length < b.length) {
                    if (log.isDebugEnabled()) {
                        log.debug("Compressed " + o.getClass().getName() + " from "
                                + b.length + " to " + compressed.length);
                    }
                    b = compressed;
                    flags |= COMPRESSED;
                } else {
                    if (log.isDebugEnabled()) {
                        log.debug("Compression increased the size of "
                                + o.getClass().getName() + " from " + b.length
                                + " to " + compressed.length);
                    }
                }
            }
        }

        return new CachedData(flags, b, this.maxSize, -1);
    }

    private byte[] processXCompress(XCompress xCompress){
        byte compressed = 1;
        byte[] compressedData = compress(xCompress.getBytes());
        if(xCompress.getBytes().length < compressedData.length){
            compressedData = xCompress.getBytes();
            compressed = 0;
        }
        byte[] compressedDataLength = toByteArray(compressedData.length);

        byte[] joinedData = null;
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        try {
            byteArrayOutputStream.write(compressed);
            byteArrayOutputStream.write(compressedDataLength);
            byteArrayOutputStream.write(compressedData);

            joinedData = byteArrayOutputStream.toByteArray();
        }catch (Exception e){
            log.error("compress XCompress error", e);
        }finally {
            try {
                byteArrayOutputStream.close();
            } catch (IOException e) {
            }
        }

        return joinedData;
    }

    private byte[] toByteArray(int value){
        return new byte[] {
                (byte) (value >> 24),
                (byte) (value >> 16),
                (byte) (value >> 8),
                (byte) value};
    }

    public int fromBytes(byte b1, byte b2, byte b3, byte b4) {
        return b1 << 24 | (b2 & 0xFF) << 16 | (b3 & 0xFF) << 8 | (b4 & 0xFF);
    }
}



test code for net.rubyeye.xmemcached.MemcachedClient 

package com.collonn.javaUtilMvn.memcache;

import com.collonn.javaUtilMvn.memcache.transcoder.XCompress;
import com.collonn.javaUtilMvn.memcache.transcoder.XTranscoder;
import net.rubyeye.xmemcached.MemcachedClient;
import net.rubyeye.xmemcached.XMemcachedClientBuilder;
import net.rubyeye.xmemcached.command.BinaryCommandFactory;
import net.rubyeye.xmemcached.utils.AddrUtil;

import java.io.IOException;
import java.util.Date;

public class XMemcachedMemTest {
    public static MemcachedClient memClient;

    static {
        try {
            XMemcachedClientBuilder builder = new XMemcachedClientBuilder(AddrUtil.getAddresses("127.0.0.1:11211"));
            builder.setCommandFactory(new BinaryCommandFactory());
            builder.setConnectTimeout(5000);
            builder.setOpTimeout(5000);
            XTranscoder xTranscoder = new XTranscoder();
            xTranscoder.setCompressionThreshold(10);
            builder.setTranscoder(xTranscoder);
//            builder.setConnectionPoolSize(10);
//            builder.setSocketOption(StandardSocketOption.SO_RCVBUF, 32 * 1024); // 设置接收缓存区为32K，默认16K
//            builder.setSocketOption(StandardSocketOption.SO_SNDBUF, 16 * 1024); // 设置发送缓冲区为16K，默认为8K
//            builder.setSocketOption(StandardSocketOption.TCP_NODELAY, false); // 启用nagle算法，提高吞吐量，默认关闭
            memClient = builder.build();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws Exception {
        try {
            String key = "Jelly-key-" + new Date().getTime();

            String v1 = "Welcome to Fabric’s documentation.";
            memClient.set(key, 20, new XCompress(v1));
            String v2 = "Usage documentation";
            memClient.append(key, new XCompress(v2));
            String value = memClient.get(key);
            System.out.println("final data as follows:\n" + value);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if(memClient != null){
                memClient.shutdown();
            }
        }
    }
}

Transcoder for net.spy.memcached.MemcachedClient 

package com.collonn.javaUtilMvn.memcache.transcoder;

import net.spy.memcached.CachedData;
import net.spy.memcached.transcoders.BaseSerializingTranscoder;
import net.spy.memcached.transcoders.Transcoder;
import net.spy.memcached.transcoders.TranscoderUtils;
import net.spy.memcached.util.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.Date;

/**
 * Transcoder that serializes and compresses objects.
 */
public class SpyTranscoder extends BaseSerializingTranscoder implements Transcoder<Object> {
    protected static final Logger log = LoggerFactory.getLogger(SpyTranscoder.class);

    // General flags
    static final int SERIALIZED = 1;
    static final int COMPRESSED = 2;

    // Special flags for specially handled types.
    private static final int SPECIAL_MASK = 0xff00;
    static final int SPECIAL_BOOLEAN = (1 << 8);
    static final int SPECIAL_INT = (2 << 8);
    static final int SPECIAL_LONG = (3 << 8);
    static final int SPECIAL_DATE = (4 << 8);
    static final int SPECIAL_BYTE = (5 << 8);
    static final int SPECIAL_FLOAT = (6 << 8);
    static final int SPECIAL_DOUBLE = (7 << 8);
    static final int SPECIAL_BYTEARRAY = (8 << 8);
    static final int SPECIAL_XCOMPRESSED = (9 << 8);

    private final TranscoderUtils tu = new TranscoderUtils(true);

    /**
     * Get a serializing transcoder with the default max data size.
     */
    public SpyTranscoder() {
        this(CachedData.MAX_SIZE);
    }

    /**
     * Get a serializing transcoder that specifies the max data size.
     */
    public SpyTranscoder(int max) {
        super(max);
    }

    /*
     * (non-Javadoc)
     *
     * @see net.spy.memcached.Transcoder#decode(net.spy.memcached.CachedData)
     */
    public Object decode(CachedData d) {
        byte[] data = d.getData();
        Object rv = null;
        if ((d.getFlags() & COMPRESSED) != 0) {
            data = decompress(d.getData());
        }
        int flags = d.getFlags() & SPECIAL_MASK;
        if ((d.getFlags() & SERIALIZED) != 0 && data != null) {
            rv = deserialize(data);
        } else if (flags != 0 && data != null) {
            switch (flags) {
                case SPECIAL_BOOLEAN:
                    rv = Boolean.valueOf(tu.decodeBoolean(data));
                    break;
                case SPECIAL_INT:
                    rv = Integer.valueOf(tu.decodeInt(data));
                    break;
                case SPECIAL_LONG:
                    rv = Long.valueOf(tu.decodeLong(data));
                    break;
                case SPECIAL_DATE:
                    rv = new Date(tu.decodeLong(data));
                    break;
                case SPECIAL_BYTE:
                    rv = Byte.valueOf(tu.decodeByte(data));
                    break;
                case SPECIAL_FLOAT:
                    rv = new Float(Float.intBitsToFloat(tu.decodeInt(data)));
                    break;
                case SPECIAL_DOUBLE:
                    rv = new Double(Double.longBitsToDouble(tu.decodeLong(data)));
                    break;
                case SPECIAL_BYTEARRAY:
                    rv = data;
                    break;
                case SPECIAL_XCOMPRESSED:
                    rv = decodeXCompress(data);
                    break;
                default:
                    getLogger().warn("Undecodeable with flags %x", flags);
            }
        } else {
            rv = decodeString(data);
        }
        return rv;
    }

    protected final Object decodeXCompress(byte[] data) {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        String str = null;

        try {
            int nextIdx = 0;
            int total = data.length;
            while (nextIdx < total) {
                byte compressedByte = data[nextIdx];

                int length = fromBytes(data[nextIdx + 1], data[nextIdx + 2], data[nextIdx + 3], data[nextIdx + 4]);
                byte[] dataBlock = Arrays.copyOfRange(data, nextIdx + 5, nextIdx + 5 + length);
                if (compressedByte == 1) {
                    dataBlock = decompress(dataBlock);
                }

                byteArrayOutputStream.write(dataBlock);
                nextIdx += (1 + 4 + length);
            }

            byte[] deCompressData = byteArrayOutputStream.toByteArray();
            str = decodeString(deCompressData);
        }catch (Exception e){
            log.error("deCompress XCompress error", e);
        }finally {
            try {
                byteArrayOutputStream.close();
            } catch (IOException e) {

            }
        }

        return str;
    }

    /*
     * (non-Javadoc)
     *
     * @see net.spy.memcached.Transcoder#encode(java.lang.Object)
     */
    public CachedData encode(Object o) {
        byte[] b = null;
        int flags = 0;
        if (o instanceof String) {
            b = encodeString((String) o);
            if (StringUtils.isJsonObject((String) o)) {
                return new CachedData(flags, b, getMaxSize());
            }
        } else if (o instanceof Long) {
            b = tu.encodeLong((Long) o);
            flags |= SPECIAL_LONG;
        } else if (o instanceof Integer) {
            b = tu.encodeInt((Integer) o);
            flags |= SPECIAL_INT;
        } else if (o instanceof Boolean) {
            b = tu.encodeBoolean((Boolean) o);
            flags |= SPECIAL_BOOLEAN;
        } else if (o instanceof Date) {
            b = tu.encodeLong(((Date) o).getTime());
            flags |= SPECIAL_DATE;
        } else if (o instanceof Byte) {
            b = tu.encodeByte((Byte) o);
            flags |= SPECIAL_BYTE;
        } else if (o instanceof Float) {
            b = tu.encodeInt(Float.floatToRawIntBits((Float) o));
            flags |= SPECIAL_FLOAT;
        } else if (o instanceof Double) {
            b = tu.encodeLong(Double.doubleToRawLongBits((Double) o));
            flags |= SPECIAL_DOUBLE;
        } else if (o instanceof byte[]) {
            b = (byte[]) o;
            flags |= SPECIAL_BYTEARRAY;
        } else {
            if(!(o instanceof XCompress)){
                b = serialize(o);
                flags |= SERIALIZED;
            }
        }

        assert b != null;

        if(o instanceof XCompress){
            flags = SPECIAL_XCOMPRESSED;
            b = processXCompress((XCompress)o);
        }else{
            if (b.length > compressionThreshold) {
                byte[] compressed = compress(b);
                if (compressed.length < b.length) {
                    getLogger().debug("Compressed %s from %d to %d",
                            o.getClass().getName(), b.length, compressed.length);
                    b = compressed;
                    flags |= COMPRESSED;
                } else {
                    getLogger().info("Compression increased the size of %s from %d to %d",
                            o.getClass().getName(), b.length, compressed.length);
                }
            }
        }

        return new CachedData(flags, b, getMaxSize());
    }

    private byte[] processXCompress(XCompress xCompress){
        byte compressed = 1;
        byte[] compressedData = compress(xCompress.getBytes());
        if(xCompress.getBytes().length < compressedData.length){
            compressedData = xCompress.getBytes();
            compressed = 0;
        }
        byte[] compressedDataLength = toByteArray(compressedData.length);

        byte[] joinedData = null;
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        try {
            byteArrayOutputStream.write(compressed);
            byteArrayOutputStream.write(compressedDataLength);
            byteArrayOutputStream.write(compressedData);

            joinedData = byteArrayOutputStream.toByteArray();
        }catch (Exception e){
            log.error("compress XCompress error", e);
        }finally {
            try {
                byteArrayOutputStream.close();
            } catch (IOException e) {
            }
        }

        return joinedData;
    }

    private byte[] toByteArray(int value){
        return new byte[] {
                (byte) (value >> 24),
                (byte) (value >> 16),
                (byte) (value >> 8),
                (byte) value};
    }

    public int fromBytes(byte b1, byte b2, byte b3, byte b4) {
        return b1 << 24 | (b2 & 0xFF) << 16 | (b3 & 0xFF) << 8 | (b4 & 0xFF);
    }
}




test code for net.spy.memcached.MemcachedClient 

package com.collonn.javaUtilMvn.memcache;

import com.collonn.javaUtilMvn.memcache.transcoder.SpyTranscoder;
import com.collonn.javaUtilMvn.memcache.transcoder.XCompress;
import net.spy.memcached.ConnectionFactory;
import net.spy.memcached.ConnectionFactoryBuilder;
import net.spy.memcached.MemcachedClient;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class SpyMemcachedMemTest {
    public static MemcachedClient memClient;

    static {
        try {
            ConnectionFactoryBuilder builder = new ConnectionFactoryBuilder();
            SpyTranscoder spyTranscoder = new SpyTranscoder();
            spyTranscoder.setCompressionThreshold(10);
            builder.setTranscoder(spyTranscoder);
            ConnectionFactory connectionFactory = builder.build();
            List<InetSocketAddress> serverList = new ArrayList<>();
            serverList.add(new InetSocketAddress("127.0.0.1", 11211));
            memClient = new MemcachedClient(connectionFactory, serverList);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws Exception {
        try {
            String key = "Jelly-key-" + new Date().getTime();

            String v1 = "Welcome to Fabric’s documentation.";
            memClient.set(key, 20, new XCompress(v1));
            String v2 = "Usage documentation";
            memClient.append(key, new XCompress(v2));
            String value = (String)memClient.get(key);
            System.out.println("final data as follows:\n" + value);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if(memClient != null){
                memClient.shutdown();
            }
        }
    }
}


冰冻火山
关注
专栏目录
πFlow是一个简单易用，功能强大的大数据流水线系统
04-20
简单易用 可视化配置流水线 监控流水线 查看流水线日志 ...包括Hadoop 、Spark、MLlib、Hive、Solr、Redis、MemCache、ElasticSearch、JDBC、MongoDB、HTTP、FTP、XML、CSV、JSON等 集成了微生物领域的相关算法
Java笔记（14）-字节数组（ByteArray）流
孤独的狂欢
04-25 5347
与之前的文件流不同，之前的所有文件流，读取文件的位置，也就是源，其实都是在磁盘之中，Java无法直接访问，是需要通过操作系统的帮助才行；但是ByteArray不一样，他就叫字节数组，可以说是另外一个地方的某个内存数据； jvm虚拟机只能访问内存数据，字节数组就是一些重要的内存数据（二进制），使用Java操作这一组二进制流时，就是使用字节数组流的方式操作；更重要的是数据（如字符串等）都可以转化成...
XMemcached客户端序列化方式
xiemingmei的专栏
03-18 230
XMemcached客户端序列化方式 默认为SerializingTranscoder 见XMemcachedClientBuilder的代码： Transcoder transcoder = new SerializingTranscoder(); 也可使用Kryo序列化, 但有bug, 数据类新老版本不兼容。 最优选Hessian序列化, 数据类新老版本兼容。...
深入探索Memcached：数据压缩策略与实践指南
2401_85702623的博客
07-12 560
Memcached是一个基于内存的键值存储系统，它通过缓存常用数据来提高应用程序的性能。其工作原理是将数据存储在内存中，当数据被请求时，首先检查Memcached，如果数据存在，则直接返回，否则从数据库中获取并存储到Memcached中以供后续使用。
Memcached gets 命令
csbysj2020的博客
09-12 235
Memcached 是一种高性能的分布式内存对象缓存系统，通常用于缓存数据库调用、API响应或页面渲染等，以减轻后端数据库的负载，提高应用的响应速度。在 Memcached 中，gets命令是一个重要的功能，它用于获取与指定的键关联的值，并返回该值以及一个唯一的标志符（CAS token），这个标志符在每次数据更新时都会改变。本文将详细介绍 Memcached 中的gets命令，包括其用法、返回值以及在实际应用中的作用。
memcache常用命令
Hanyinh的博客
07-03 1130
memcache常用命令 memcache常用命令 两篇文章综合起来看 基本命令： 存储命令； <command name> <key> <flag> <expire> <bytes> <data block> 1、set 无论如何都存储，数据不存在时存储，数据存在时更新 set mykey 0 0 3 123 STORED set mykey 0 0 3 456 STORED 2、add 当数
Memcached缓存技术（二）：存储命令：set；add；replace；append；prepend；cas
weixin_46055386的博客
08-23 894
memcached链接 可以通过 telnet 命令并指定主机ip和端口来连接 Memcached 服务。 语法：telnet HOST PORT 命令中的 HOST 和 PORT 为运行 Memcached 服务的 IP 和 端口。 memcached命令 1.Memcached 存储命令 1.Memcached set 命令 2.Memcached add 命令 3.Memcached replace 命令 4.Memcached append 命令 5.Memcached prep
Memcache常用命令.pdf
06-19
- `append <key> <flags> <expiration> <bytes> [value]`: 追加数据到已存在的键后。 - **前置数据**: - `prepend <key> <flags> <expiration> <bytes> [value]`: 将数据前置到已存在的键之前。 - **增量操作**: ...
Lnmp+memcache+memcached
08-01
【 Lnmp 环境构建与 Memcache/Memcached 集成】 在 IT 领域，LNMP 是一种常见的服务器架构，由 Linux 操作系统、Nginx Web 服务器、MySQL 数据库和 PHP 解释器组成。这种架构常用于高性能、低资源消耗的 Web 应用...
MemCache开发说明文档
09-22
MemCache是一种广泛应用于Web开发中的高性能分布式内存对象缓存系统，其主要目的是通过将数据存储在内存中，以便快速访问，从而显著提升系统的响应速度。最初由Danga Interactive开发，主要用于提升LiveJournal的...
windows版本可用的memcache版本
最新发布
09-24
分布式缓存：它可以运行在多个服务器上，为大规模分布式系统提供服务。 多线程支持：Memcached 能够在多核系统上通过多线程来提高性能。 存储灵活性：Memcached 支持存储各种类型的数据，包括文本、图片等。 过期...
缓存管理方案 AutoLoadCache (spring注解管理缓存，可与redis，mencache等对接)
dac55300424的专栏
12-03 4598
AutoLoadCache 是使用 Spring AOP 、 Annotation以及Spring EL表达式 来进行管理缓存的解决方案，同时基于AOP实现自动加载机制来达到数据“常驻内存”的目的。 现在使用的缓存技术很多，比如Redis、 Memcache 、 EhCache等，甚至还有使用ConcurrentHashMap 或HashTable 来实现缓存。但在缓存的使用上，每个人都有自
at net.spy.memcached.transcoders.BaseSerializingTranscoder.serialize
newtelcom的专栏
01-10 1379
at net.spy.memcached.transcoders.BaseSerializingTranscoder.serialize
java之XMemcached使用及源码详解
qian9140的博客
02-03 262
转载请注明出处：http://blog.csdn.net/tang9140/article/details/43445511 前言 本文主要讲述如何使用XMemcached客户端与Memcached服务端进行交互。通过XMemcached的API调用与Memcached的set/get命令对比及跟踪XMemcached源码，使大家对XMemcached的API有更深层次的理解，能够从底层...
浅谈Memcached中的压缩存储
最实用的Linux博客
03-10 4953
 原贴:http://blog.alwaysmylove.net/2008/04/09/compress-storage-in-memcache/ 浅谈Memcached中的压缩存储 PHPMySQL 标签: compress, memcached, PHPMySQL 点击次数: 198
Memcached append 命令
hqmln的博客
10-13 204
Memcached append 命令用于向已存在 key(键) 的 value(数据值) 后面追加数据 。 语法： append 命令的基本语法格式如下： append key flags exptime bytes [noreply] value             ...
memcached--存储命名--append
顽石的专栏
07-18 357
Memcached append 命令用于向已存在 key(键) 的 value(数据值) 后面追加数据 。语法：append 命令的基本语法格式如下：append key flags exptime bytes [noreply] value参数说明如下： key：键值 key-value 结构中的 key，用于查找缓存值。 flags：可以包括键值对的整型参数，客户机使用它存储关于键值对的额
Memcache存储大数据的问题
热门推荐
黄规速博客:学如逆水行舟，不进则退
01-25 4万+
Memcache存储大数据的问题   huangguisu       Memcached存储单个item最大数据是在1MB内，如果数据超过1M,存取set和get是都是返回false，而且引起性能的问题。 我们之前对排行榜的数据进行缓存，由于排行榜在我们所有sql select查询里面占了30%，而且我们排行榜每小时更新一次，所以必须对数据做缓存。为了清除缓存方便，把所有的用户的数据放在
从零开始学习Memcached之append命令测试
luyaran的博客
06-13 334
    Memcached append 命令用于向已存在 key(键) 的 value(数据值) 后面追加数据。append 命令的基本语法格式如下：append key flags exptime bytes [noreply] value    参数说明如下：key：键值 key-value 结构中的 key，用于查找缓存值。flags：可以包括键值对的整型参数，客户机使用它存储关于键值对的...
Memcache缓存技术详解：大并发网站的秘密武器
Memcache是一个广泛使用的分布式内存缓存系统，主要用于提高大并发网站的效率，减轻数据库的压力。它通过将常用数据存储在内存中，从而避免了频繁的数据库读写操作，显著提升了数据访问的速度。在描述中提到了一些...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值