常用缓存技术

热数据缓存

这是使用缓存最频繁最直接的方式，即我们把需要频繁访问DB的数据加载到内存里面，以提高响应速度。通常我们的做法是使用一个ConcuccrentHashMap<Request, AtomicInteger>来记录一天当中每个请求的次数，每天凌晨取出昨天访问最频繁的K个请求（K取多少个取决你的可用内存有多少），从DB中读取这些请求的返回结果放到一个ConcuccrentHashMap<Request, Response>容器中，然后把所有请求计数清0，重新开始计数。

LRU缓存

热数据缓存适用于那些热数据比较明显且稳定的业务场景，而对于那些热数据不稳定的应用场景我们需要发明一种动态的热数据识别方式。我们都知道常用的内存换页算法有2种：LFU和LRU。

LFU(Least Frequently Used)是把那些最近最不经常使用的页面置换出去，这跟上面讲的热数据缓存是一个道理，缺点有2个：

1. 需要维护一个计数器，记住每个页面的使用次数。
2. 上一个时间段频繁使用的，在下一个时间段不一定还频繁。

LRU(Least Recently Used)策略是把最近最长时间未使用的页面置换出去。实现起来很简单，只需要一个链表结构，每次访问一个元素时把它移到链表的尾部，当链表已满需要删除元素时就删除头部的元素，因为头部的元素就是最近最长时间未使用的元素。

import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 利用LinkedHashMap实现一个定长容量的，先进先出的队列。当指定按访问顺序排序时，就实际上是一个最近最少使用LRU队列<br>
 * <br>
 * 根据链表中元素的顺序可以分为：按插入顺序的链表，和按访问顺序(调用get方法)的链表。<br>
 * 默认是按插入顺序排序，如果指定按访问顺序排序，那么调用get方法后，会将这次访问的元素移至链表尾部。<br>
 * 不断访问可以形成按访问顺序排序的链表。<br>
 * 可以重写removeEldestEntry方法返回true值指定插入元素时移除最老的元素。<br>
 * 
 * @Author:zhangchaoyang
 * @Since:2014-9-5
 * @Version:1.0
 */
public class LRUCache<K, V> extends LinkedHashMap<K, V> {

    private static final long serialVersionUID = -2045058079564141163L;

    private final int maxCapacity;

    // 本类中设置装载因子实际没有意义，因为容量超过maxCapacity时就会把元素移除掉
    private static final float DEFAULT_LOAD_FACTOR = 1f;

    private final ReadWriteLock lock = new ReentrantReadWriteLock();

    public LRUCache(int maxCapacity) {
        super(maxCapacity, DEFAULT_LOAD_FACTOR, true);// 第3个参数false表示维持插入顺序，这样最早插入的将最先被移除。true表示维持访问顺序，调用get方法后，会将这次访问的元素移至链表尾部，删除老元素时会删除表头元素。
        this.maxCapacity = maxCapacity;
    }

    @Override
    protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {
        return size() > maxCapacity;// 到达maxCapacity时就移除老元素，这样实现定长的LinkedHashMap
    }

    @Override
    public boolean containsKey(Object key) {
        try {
            lock.readLock().lock();
            return super.containsKey(key);
        } finally {
            lock.readLock().unlock();
        }
    }

    @Override
    public V get(Object key) {
        try {
            lock.readLock().lock();
            return super.get(key);
        } finally {
            lock.readLock().unlock();
        }
    }

    @Override
    public V put(K key, V value) {
        try {
            lock.writeLock().lock();
            return super.put(key, value);
        } finally {
            lock.writeLock().unlock();
        }
    }

    public int size() {
        try {
            lock.readLock().lock();
            return super.size();
        } finally {
            lock.readLock().unlock();
        }
    }

    public void clear() {
        try {
            lock.writeLock().lock();
            super.clear();
        } finally {
            lock.writeLock().unlock();
        }
    }

    public Collection<Map.Entry<K, V>> getAll() {
        try {
            lock.readLock().lock();
            return new ArrayList<Map.Entry<K, V>>(super.entrySet());
        } finally {
            lock.readLock().unlock();
        }
    }
}

TimeOut缓存

Timeout缓存常用于那些跟用户关联的请求数据，比如用户在翻页查看一个列表数据时，他第一次看N页的数据时，服务器是从DB中读取的相应数据，当他看第N+1页的数据时应该把第N页的数据放入缓存，因为用户可能呆会儿还会回过头来看第N页的数据，这时候服务器就可以直接从缓存中获取数据。如果用户在5分钟内还没有回过头来看第N页的数据，那么我们认为他再看第N页的概率就非常低了，此时可以把第N页的数据从缓存中移除，实际上相当于我们为缓存设置了一个超时时间。

我想了一种Timeout缓存的实现方法。还是用ConcurrentHashMap来存放key-value，另建一棵小顶堆，每个节点上存放key以及key的到期时间，建堆时依据到期时间来建。开一个后台线程不停地扫描堆顶元素，拿当前的时间戳去跟堆顶的到期时间比较，如果当前时间晚于堆顶的到期时间则删除堆顶，把堆顶里存放的key从ConcurrentHashMap中删除。删除堆顶的时间复杂度为$O(log_2{N})$，具体步骤如下：

1. 用末元素替换堆顶元素root
   

2. 临时保存root节点。从上往下遍历树，用子节点中较小那个替换父节点。最后把root放到叶节点上
   

下面的代码是直接基于java中的java.util.concurrent.Delayed实现的，Delayed是不是基于上面的小顶堆的思想我也没去深入研究。

TimeoutCache.java

import java.io.IOException;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.TimeUnit;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * 可以为每个元素设置存活时间的缓存容器
 * 
 * @Author:orisun
 * @Since:2015-10-9
 * @Version:1.0
 */
public class TimeoutCache<K, V> {

    private static final Log logger = LogFactory.getLog(TimeoutCache.class);
    private ConcurrentMap<K, V> cacheObjMap = new ConcurrentHashMap<K, V>();
    private DelayQueue<DelayItem<Pair<K, V>>> queue = new DelayQueue<DelayItem<Pair<K, V>>>();
    private Thread daemonThread;

    public TimeoutCache() {
        Runnable daemonTask = new Runnable() {
            public void run() {
                daemonCheck();
            }
        };
        daemonThread = new Thread(daemonTask);
        daemonThread.setDaemon(true);
        daemonThread.setName("TimeoutCache Daemon Check");
        daemonThread.start(); // 启动后台线程，对容器中的元素不停地进行轮循，将过期的元素移除出出去
    }

    private void daemonCheck() {
        logger.info("check timeout element of cache started");
        for (;;) {
            try {
                DelayItem<Pair<K, V>> delayItem = queue.take();// 如果所有元素都没有超时，该行代码会阻塞
                if (delayItem != null) {
                    Pair<K, V> pair = delayItem.getItem();
                    cacheObjMap.remove(pair.first, pair.second); // 超时对象，从容器中移除
                }
            } catch (InterruptedException e) {
                logger.error("take timeout element from cache failed", e);
                break; // 检测到中断时就退出循环
            }
        }
        logger.info("check timeout element of cache stopped.");
    }

    /**
     * 以覆盖的方式向缓存中添加对象,缓存以<key,value>的形式存在.<br>
     * 注意：value如果是List，则它不是由通过List.subList()得来的
     * 。因为List.subList()返回的是一个RandomAccessSubList实例
     * ,在反序列化时ObjectOutputStream.writeObject(RandomAccessSubList)会出错
     * 
     * @param key
     * @param value
     * @param time
     *            对象在缓存中的生存时间
     * @param unit
     *            时间单位
     */
    public void put(K key, V value, long time, TimeUnit unit) {
        V oldValue = cacheObjMap.put(key, value);
        if (oldValue != null)
            queue.remove(key);

        long nanoTime = TimeUnit.NANOSECONDS.convert(time, unit);
        queue.put(new DelayItem<Pair<K, V>>(new Pair<K, V>(key, value),
                nanoTime));
    }

    /**
     * 根据key从缓存中取得对应的value,如果key不存在则返回null<br>
     * 取出的是value的深拷贝
     * 
     * @param key
     * @return
     */
    @SuppressWarnings("unchecked")
    public V get(K key) {
        try {
            return (V) JavaSerializer.deepCopy(cacheObjMap.get(key));
        } catch (ClassNotFoundException | IOException e) {
            e.printStackTrace();
            return null;
        }
    }

}

DelayItem.java

import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;

/**
 * 
 * @Author:orisun
 * @Since:2015-10-9
 * @Version:1.0
 */
public class DelayItem<T> implements Delayed {

    private static final long ORIGIN = System.nanoTime();// 记录进入队列的时刻
    private static final AtomicLong sequencer = new AtomicLong(0);
    private final long sequenceNumber;
    private final long time;
    private final T item;

    final static long now() {
        return System.nanoTime() - ORIGIN;
    }

    /**
     * 
     * @param submit
     *            队列中的元素类型
     * @param timeout
     *            元素在队列中存活的时间，单位：毫秒
     */
    public DelayItem(T submit, long timeout) {
        this.time = now() + timeout;// 出队时刻
        this.item = submit;// 入队元素
        this.sequenceNumber = sequencer.getAndIncrement();// 在队列中的编号
    }

    public T getItem() {
        return this.item;
    }

    @Override
    public long getDelay(TimeUnit unit) {
        long d = unit.convert(time - now(), TimeUnit.NANOSECONDS);
        return d;
    }

    @Override
    public int compareTo(Delayed other) {
        if (other == this)
            return 0;
        if (other instanceof DelayItem) {
            DelayItem<?> x = (DelayItem<?>) other;
            long diff = time - x.time;
            if (diff < 0)
                return -1;
            else if (diff > 0)
                return 1;
            else if (sequenceNumber < x.sequenceNumber) // 如果是同时进入队列的，则先进者先出
                return -1;
            else
                return 1;
        }
        long d = (getDelay(TimeUnit.NANOSECONDS) - other
                .getDelay(TimeUnit.NANOSECONDS));
        return (d == 0) ? 0 : ((d < 0) ? -1 : 1);
    }
}

JavaSerializer.java

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class JavaSerializer {

    public static Object deepCopy(Object obj) throws IOException,
            ClassNotFoundException {
        // 将该对象序列化成流,因为写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。所以利用这个特性可以实现对象的深拷贝
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(obj);// 要写入ObjectOutputStream的话必须实现Serializable接口
        // 将流序列化成对象
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }
}

Redis省内存的技巧

 redis自带持久化功能，当它决定要把哪些数据换出内存写入磁盘时，使用的也是LRU算法。同时redis也有timeout机制，但它不像上面的TimeoutCache.java类一样开个无限循环的线程去扫描到期的元素，而是每次get元素时判断一个该元素有没有到期，所以redis中一个元素的存活时间远远超出了设置的时间是很正常的。

本节想讲的重点其实是redis省内存的技巧，这也是实践中经常遇到的问题，因为内存总是很昂贵的，运维大哥总是很节约的。在我们的推荐系数中使用Redis来存储信息的索引，没有使用Lucene是因为Lucene不支持分布式，但是省内存的技巧都是从Lucene那儿学来的。

首先，如果你想为redis节省内存那你就不能再用<String,String>类型的key-value结构，必须全部将它们序列化成二进制的形式。我写了一个工具类，实现各种数据类型和byte[]的互相置换。

DataTransform.java

import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;

/**
 * 各种数据类型的相互转换<br>
 * <ul>
 * <li>{@code <<} 左移，符号位不动
 * <li>{@code >>} 右移，符号位不动
 * <li>{@code >>>} 循环右移，符号位要跟着移，高位用0填充
 * </ul>
 * 位移运算只对32位和64位值有意义。位移运算返回一个新值，但是不改变原值。
 * 
 * @Author:zhangchaoyang
 * @Since:2014-7-9
 * @Version:
 */
public class DataTransform {

    private static final char[] Digit = { '0', '1', '2', '3', '4', '5', '6',
            '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };

    /**
     * byte数组转换成int
     * 
     * @param bRefArr
     *            byte数组
     * @param LowEndian
     *            byte数组是否按小端字节序存储
     * @return int值
     * @throws ArgumentException
     *             byte数组长度超过4时抛出该异常
     */
    public static int bytesToInt(byte[] bRefArr, boolean LowEndian)
            throws ArgumentException {
        int len = bRefArr.length;
        if (len > 4) {
            throw new ArgumentException("字节数组长度不能超过4");
        }

        int iOutcome = 0;
        byte bLoop;
        for (int i = 0; i < len; i++) {
            bLoop = bRefArr[i];
            int shift;
            if (LowEndian) {
                shift = i;
            } else {
                shift = len - 1 - i;
            }
            iOutcome += (bLoop & 0xFF) << (8 * shift);// 之所以要跟0xFF进行与运行是为了把bLoop转换成int,去除符号位的影响
        }
        return iOutcome;
    }

    /**
     * byte数组转换成long
     * 
     * @param bRefArr
     *            byte数组
     * @param LowEndian
     *            byte数组是否按小端字节序存储
     * @return long值
     * @throws ArgumentException
     *             byte数组长度超过8时抛出该异常
     */
    public static long bytesToLong(byte[] bRefArr, boolean LowEndian)
            throws ArgumentException {
        int len = bRefArr.length;
        if (len > 8) {
            throw new ArgumentException("字节数组长度不能超过8");
        }

        long iOutcome = 0;
        byte bLoop;
        for (int i = 0; i < len; i++) {
            bLoop = bRefArr[i];
            int shift;
            if (LowEndian) {
                shift = i;
            } else {
                shift = len - 1 - i;
            }
            iOutcome += (bLoop & 0xFFL) << (8 * shift);// 之所以要跟0xFFL进行与运行是为了把bLoop转换成long,去除符号位的影响
        }
        return iOutcome;
    }

    /**
     * byte数组转换成double
     * 
     * @param bRefArr
     *            byte数组
     * @param LowEndian
     *            byte数组是否按小端字节序存储
     * @return double值
     * @throws ArgumentException
     *             byte数组长度超过8时抛出该异常
     */
    public static double bytesToDouble(byte[] bRefArr, boolean LowEndian)
            throws ArgumentException {
        long l = bytesToLong(bRefArr, LowEndian);
        return Double.longBitsToDouble(l);
    }

    /**
     * int转换为byte数组,采用大端字节序会更快一些
     * 
     * @param number
     *            int数
     * @param LowEndian
     *            byte数组是否按小端字节序存储
     * @return byte数组
     */
    public static byte[] intToBytes(int number, boolean LowEndian) {
        int len = 4;
        byte[] rect = new byte[len];
        for (int i = 0; i < len; i++) {
            rect[i] = (byte) (number >>> (len - 1 - i) * 8);
        }
        if (LowEndian) {
            for (int i = 0; i < len / 2; i++) {
                byte swap = rect[i];
                rect[i] = rect[len - i - 1];
                rect[len - i - 1] = swap;
            }
        }
        return rect;
    }

    /**
     * 仿照Lucene的可变长度整型:最高位表示是否还有字节要读取，低七位就是就是具体的有效位，添加到结果数据中.<br>
     * 比如00000001 最高位表示0，那么说明这个数就是一个字节表示，有效位是后面的七位0000001，值为1。10000010 00000001
     * 第一个字节最高位为1
     * ，表示后面还有字节，第二位最高位0表示到此为止了，即就是两个字节，那么具体的值注意，是从最后一个字节的七位有效数放在最前面，依次放置
     * ，最后是第一个自己的七位有效位，所以这个数表示 0000001 0000010，换算成整数就是130。<br>
     * 用VInt来表示Integer.MAX_VALUE时需要5个字节.
     * 
     * @param num
     * @return
     */
    public static byte[] vintToByte(int num) {
        ByteBuffer buffer = ByteBuffer.allocate(32);
        while ((num & ~0x7F) != 0) {
            buffer.put((byte) ((num & 0x7F) | 0x80));
            num >>>= 7;// 等价于num=num>>>7;
        }
        buffer.put((byte) num);
        byte[] rect = new byte[buffer.position()];
        buffer.flip();
        buffer.get(rect);
        return rect;
    }

    public static byte[] vintArrToByteArr(int[] arr) {
        ByteBuffer buffer = ByteBuffer.allocate(32 * arr.length);
        for (int ele : arr) {
            byte[] brr = vintToByte(ele);
            buffer.put(brr);
        }
        byte[] rect = new byte[buffer.position()];
        buffer.flip();
        buffer.get(rect);
        return rect;
    }

    /**
     * 仿照Lucene的可变长度整型
     * 
     * @see #vintToByte
     * @param bytes
     * @return
     */
    public static int byteToVInt(byte[] bytes) {
        int i = 0;
        byte b = bytes[i++];
        int num = b & 0x7F;
        for (int shift = 7; (b & 0x80) != 0; shift += 7) {
            b = bytes[i++];
            num |= (b & 0x7F) << shift;
        }
        return num;
    }

    public static int[] byteArrToVIntArr(byte[] bytes) {
        List<Integer> list = new ArrayList<Integer>();
        int i = 0;
        while (i < bytes.length) {
            byte b = bytes[i++];
            int num = b & 0x7F;
            for (int shift = 7; (b & 0x80) != 0; shift += 7) {
                b = bytes[i++];
                num |= (b & 0x7F) << shift;
            }
            list.add(num);
        }
        int[] rect = new int[list.size()];
        for (int j = 0; j < rect.length; j++) {
            rect[j] = list.get(j);
        }
        return rect;
    }

    /**
     * 仿照Lucene的可变长度整型
     * 
     * @see #vintToByte
     * @param num
     * @return
     */
    public static byte[] vlongToByte(long num) {
        ByteBuffer buffer = ByteBuffer.allocate(64);
        while ((num & ~0x7F) != 0) {
            buffer.put((byte) ((num & 0x7F) | 0x80));
            num >>>= 7;
        }
        buffer.put((byte) num);
        byte[] rect = new byte[buffer.position()];
        buffer.flip();
        buffer.get(rect);
        return rect;
    }

    /**
     * 仿照Lucene的可变长度整型
     * 
     * @see #vintToByte
     * @param bytes
     * @return
     */
    public static long byteToVLong(byte[] bytes) {
        int i = 0;
        byte b = bytes[i++];
        long num = b & 0x7FL;
        for (int shift = 7; (b & 0x80) != 0; shift += 7) {
            b = bytes[i++];
            num |= (b & 0x7FL) << shift;
        }
        return num;
    }

    /**
     * long转换为byte数组
     * 
     * @param number
     *            long数
     * @param LowEndian
     *            byte数组是否按小端字节序存储
     * @return byte数组,长度为8
     */
    public static byte[] longToBytes(long number, boolean LowEndian) {
        int len = 8;
        byte[] rect = new byte[len];
        for (int i = 0; i < len; i++) {
            rect[i] = (byte) (number >>> (len - 1 - i) * 8);
        }
        if (LowEndian) {
            for (int i = 0; i < len / 2; i++) {
                byte swap = rect[i];
                rect[i] = rect[len - i - 1];
                rect[len - i - 1] = swap;
            }
        }
        return rect;
    }

    /**
     * double转换为byte数组
     * 
     * @param number
     *            double数值
     * @param LowEndian
     *            byte数组是否按小端字节序存储
     * @return byte数组,长度为8
     */
    public static byte[] doubleToBytes(double number, boolean LowEndian) {
        long l = Double.doubleToLongBits(number);
        return longToBytes(l, LowEndian);
    }

    /**
     * IP转换成int值,int在全域上和IP是一一对应的
     * 
     * @param ip
     * @return
     * @throws ArgumentException
     *             IP范围超界时抛出该异常
     */
    public static int ip2int(String ip) throws ArgumentException {
        String[] arr = ip.trim().split("\\.");
        int part1 = Integer.parseInt(arr[0]);
        int part2 = Integer.parseInt(arr[1]);
        int part3 = Integer.parseInt(arr[2]);
        int part4 = Integer.parseInt(arr[3]);
        if (part1 >= 0 && part1 < 256 && part2 >= 0 && part2 < 256
                && part3 >= 0 && part3 < 256 && part4 >= 0 && part4 < 256) {
            // 左移，正数左移之后有可能把最高位变为1，从而成为负数
            int rect = part1 << 24;
            rect += part2 << 16;
            rect += part3 << 8;
            rect += part4;
            return rect;
        } else {
            throw new ArgumentException("IP范围超界");
        }
    }

    /**
     * int值转换成IP,int在全域上和IP是一一对应的
     * 
     * @param number
     * @return
     */
    public static String int2ip(int number) {
        StringBuilder sb = new StringBuilder();
        int part1 = number >>> 24;// 右移，如果是负数最高位的1会向右移，且最高位变为0
        int part2 = (0x00ff0000 & number) >>> 16;// 位移的优先级高于与运算的优先级
        int part3 = (0x0000ff00 & number) >>> 8;
        int part4 = 0x000000ff & number;
        sb.append(String.valueOf(part1));
        sb.append(".");
        sb.append(String.valueOf(part2));
        sb.append(".");
        sb.append(String.valueOf(part3));
        sb.append(".");
        sb.append(String.valueOf(part4));
        return sb.toString();
    }

    /**
     * 一个将字节转化为十六进制ASSIC码的函数
     * 
     * @param ib
     * @return
     */
    public static String byteHEX(byte ib) {
        char[] ob = new char[2];
        ob[0] = Digit[(ib >>> 4) & 0X0F];
        ob[1] = Digit[ib & 0X0F];
        String s = new String(ob);
        return s;
    }

    public static String byteHEX(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte ib : bytes) {
            char[] ob = new char[2];
            ob[0] = Digit[(ib >>> 4) & 0X0F];
            ob[1] = Digit[ib & 0X0F];
            String s = new String(ob);
            sb.append(s);
        }
        return sb.toString();
    }

    /**
     * 把一个byte表示成二进制的字符串字面值
     * 
     * @param ib
     * @return
     */
    public static String byteLiteral(byte ib) {
        StringBuilder sb = new StringBuilder();
        for (int i = 7; i >= 0; i--) {
            int v = (ib >>> i) & 0x01;
            if (v == 0) {
                sb.append("0");
            } else {
                sb.append("1");
            }
        }
        return sb.toString();
    }

    public static String byteLiteral(byte[] ib) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < ib.length; i++) {
            sb.append(byteLiteral(ib[i]));
        }
        return sb.toString();
    }
}

请留意一下上述代码中出现了VInt和VLong两种类型，具体看注释。

倒排索引常见的形式为：term -->  [infoid1,infoid2,infoid3...]，针对这种形式的索引我们看下如何节省内存。首先value要采用redis中的list结构，而且是list<byte[]>而非list<String>（想省内存就要杜绝使用String，上面已经说过了）。假如infoid是个int，置换成byte[]就要占4个字节，而绝大部分情况下infoid都1000万以内的数字，因此使用VInt只需要3个字节。内存还可以进一步压缩。链表的第1个infoid我们存储它的VInt形式，后面的infoid与infoid1相减，差值也是个1000万以内的数字而且有可能非常小，我们采用VInt存储这个差值最多需要3个字节，有可能只需要1个字节。访问链表中的任意一个元素时都需要先把首元素取出来。

另一种常见的索引形式为：infoid --> infoDetail，infoDetail中包含很多字段，譬如city、valid、name等，通常情况下人们会使用Redis的hash结构来存储实体，而我们现在要做的就是把infoDetail这个实体序列化成尽可能短的字节流。首先city代表城市，本来是个String类型，而city这个东西是可以穷举的，我们事先对所有city进行编号，在redis中只存储city编号即可。valid表示信息是否过期是个bool类型，在java中存储一个bool也需要1个字节，这显然很浪费，本来一个bit就够了嘛，同时city又用不满一个int，所以可以让valid跟city挤一挤，把city左移一位，把valid塞到city的末位上去。

import java.nio.ByteBuffer;

/**
 * 
 *@Author:orisun 
 *@Since:2016-5-14  
 *@Version:1.0
 */
public class Info {

    private int city;
    private boolean valid;
    private String name;

    public byte[] serialize() {
        ByteBuffer buffer = ByteBuffer.allocate(10);
        int cv = (city << 1) + (valid ? 1 : 0);
        byte[] cv_b = DataTransform.intToBytes(cv, false);
        buffer.put(cv_b);
        buffer.put(name.getBytes());
        byte[] rect = new byte[buffer.position()];
        buffer.flip();
        buffer.get(rect);
        return rect;
    }

    public static Info deserialize(byte[] value) {
        if (value == null || value.length <= 4) {
            return null;
        }
        Info inst = new Info();
        try {
            int cv = DataTransform.bytesToInt(new byte[] { (byte) value[0],
                    value[1], value[2], value[3] }, false);
            inst.setValid(cv % 2 != 0);
            inst.setCity(cv >> 1);
            inst.setName(new String(value, 4, value.length - 4));
        } catch (ArgumentException e) {
            e.printStackTrace();
        }
        return inst;
    }

    public int getCity() {
        return city;
    }

    public void setCity(int city) {
        this.city = city;
    }

    public boolean isValid() {
        return valid;
    }

    public void setValid(boolean valid) {
        this.valid = valid;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public static void main(String[] args) {
        Info inst1 = new Info();
        inst1.setCity(100);
        inst1.setValid(true);
        inst1.setName("pc");
        Info inst2 = Info.deserialize(inst1.serialize());
        assert inst1.getCity() == inst2.getCity();
        assert inst1.getName().equals(inst2.getName());
        assert inst1.isValid() ^ inst2.isValid();
    }
}