redis bitmap資料結構之java對等操作

　　在之前的文章中，我們有說過bitmap，bitmap在很多場景可以應用，比如黑白名單，快速判定，登入情況等等。總之，bitmap是以其高效能出名。其基本原理是一位儲存一個標識，其他衍生知道咱就不說了，而redis就是以這種原生格式儲存的。

　　實際上，redis是基於string的資料結構實現了bitmap的功能。

1. redis基本的bitmap操作命令

　　最基本的，redis的bitmap有設定和讀取兩個值，即 setbit/getbit, 非常容易理解，即設定某個標識為1，那麼取值判定的時候，就可以得到true.

127.0.0.1:6379> setbit bm1 222 1
(integer) 0
127.0.0.1:6379> getbit bm1 222
(integer) 1

　　這很容易理解，也是最基本的。當然，它還提供其他的一些操作：BITCOUNT 做資料量統計, BITOP 做bitmap的交併差運算... 我們也不必過多討論它。

2. java中的原生bitmap

　　可以說redis的bitmap實現相當之簡單，所以java也就順便實現了一個bitmap的版本：BitSet .

    @Test
    public void testJavaBitmap() {
        BitSet bitmap = new BitSet();
        bitmap.set(88);
        // exist = true
        boolean exist = bitmap.get(88);
        BitSet bitmap2 = new BitSet();
        bitmap2.set(99);
        // bitmap中將包含 [88, 99]
        bitmap.or(bitmap2);
    }

　　java中的bitmap實現，也是按位元儲存，但是是基於long的儲存。

    /*
     * BitSets are packed into arrays of "words."  Currently a word is
     * a long, which consists of 64 bits, requiring 6 address bits.
     * The choice of word size is determined purely by performance concerns.
     */
    private final static int ADDRESS_BITS_PER_WORD = 6;
    
    /**
     * Sets the bit at the specified index to {@code true}.
     *
     * @param  bitIndex a bit index
     * @throws IndexOutOfBoundsException if the specified index is negative
     * @since  JDK1.0
     */
    public void set(int bitIndex) {
        if (bitIndex < 0)
            throw new IndexOutOfBoundsException("bitIndex < 0: " + bitIndex);

        int wordIndex = wordIndex(bitIndex);
        expandTo(wordIndex);

        words[wordIndex] |= (1L << bitIndex); // Restores invariants

        checkInvariants();
    }
    /**
     * Given a bit index, return word index containing it.
     */
    private static int wordIndex(int bitIndex) {
        return bitIndex >> ADDRESS_BITS_PER_WORD;
    }

　　所以，我們可以得出一個淺顯的結論，bitmap很簡單，一點都不神祕。但是，大道至簡，它高效能，它自然還是有好處的，咱們該用還得用。顯然，java版本的bitmap雖然很很好用，但是它只是應用級別的，只能在程序內使用，有太多的其他問題沒考慮，所以咱們還得要依賴於redis的bitmap.

　　問題：如果我有很多的數位標識想要寫入redis中，然後再進行讀取判定，該怎麼辦呢？

　　很簡單的，我們可以一個個地呼叫 setbit 命令，依次寫入redis中。這自然能解決問題，但是明顯會帶來很多的網路io。

　　其次，我們可以使用pipeline呼叫setbit進行批次寫入。這當然是一種優化方案，只是仍然不是最優。

　　那有沒有什麼更好的辦法呢？

3. java和redis的bitmap互操作

　　對於批次的操作，redis是基於string實現，而java是基於bitset實現。其功能都基本差不多，判定、寫入、交併差運算。那麼，除了一個個按照各自語法進行新增外，有沒有可能進行資料結構上的對等呢？

　　這個思路是很自然的，因為我們已經完全理解了各自的實現原理，為什麼不呢？直接將BitSet轉換為byte[]寫入redis，直接將redis的bitmap當作string讀出來不就可以了嗎？

　　事實真是如此嗎？實際上有點差別，原因是一個是大端儲存，一個是小端儲存。

　　比如：比如對於儲存byte值: 00000010 , redis中會解釋為偏移為6的值為1, 而在java中則會解析為數位2存在於bitmap中。也就是說兩個的判定結果是不一樣的，一個是6，一個是2。如果把java中的值給調換一下，變成 01000000，那麼就和redis是一樣的了。

　　而從redis中轉變到java中，則需要將每個byte位做一逆向操作判定，具體實現如下：

    @Test
    public void testSetBitmapData2Redis() {
        //建立一個連線
        Jedis jedis = new Jedis("localhost", 6379);
        // 正向設定redis bitmap
        String testBitmapKey = "mybitmap1";
        jedis.set(testBitmapKey.getBytes(),
                genRedisBitmap(2, 55, 133, 65537, 10_0000));
        Assert.assertEquals("bitmap取值不正確", true,
                jedis.getbit(testBitmapKey, 2L));
        Assert.assertEquals("bitmap取值不正確", true,
                jedis.getbit(testBitmapKey, 133L));
        Assert.assertEquals("bitmap取值不正確", true,
                jedis.getbit(testBitmapKey, 65537L));
        Assert.assertEquals("bitmap取值不正確", true,
                jedis.getbit(testBitmapKey, 10_0000L));
        Assert.assertEquals("bitmap取值不正確", false,
                jedis.getbit(testBitmapKey, 3L));
        //在redis中獲取name值
        byte[] redisBitmapData = jedis.get("mybitmap1".getBytes());
        BitSet bitSet = convertRedisBitmapToJava(redisBitmapData);
        Assert.assertTrue("redisBitmap反解不正確", bitSet.get(2));
        Assert.assertTrue("redisBitmap反解不正確", bitSet.get(133));
        Assert.assertTrue("redisBitmap反解不正確", bitSet.get(65537));
        Assert.assertTrue("redisBitmap反解不正確", bitSet.get(10_0000));
        Assert.assertFalse("redisBitmap反解不正確", bitSet.get(332));
        jedis.close();
    }

    // 將redis的bitmap轉換為java 的bitset
    private BitSet convertRedisBitmapToJava(byte[] redisBitmapData) {
        int len = redisBitmapData.length;
        BitSet bitSet = new BitSet();
        // 每個 byte 8位元, 所以整個bitmap 的長度為 len * 8
        for (int i = 0; i < len * 8; i++) {
            byte currentSegment = redisBitmapData[i / 8];
            if(currentSegment == 0) {
                continue;
            }
            if((currentSegment & (1 << (7 - (i % 8) ) ) ) != 0 ) {
                bitSet.set(i);
            }
        }
        return bitSet;
    }

    // 生成redis的bitmap資料
    private byte[] genRedisBitmap(int... items) {
        BitSet bitSet = new BitSet();
        // 2 55 133
        for (int k : items) {
            bitSet.set(k);
        }
        byte[] targetBitmap = bitSet.toByteArray();
        convertJavaToRedisBitmap(targetBitmap);
        return targetBitmap;
    }

    // 將java中的位元組陣列轉換為redis的bitmap資料形式
    private void convertJavaToRedisBitmap(byte[] bytes) {
        int len = bytes.length;
        for (int i = 0; i < len; i++) {
            byte b1 = bytes[i];
            if(b1 == 0) {
                continue;
            }
            byte transByte = 0;
            for (byte j = 0; j < 8; j++) {
                transByte |= (b1 & (1 << j)) >> j << (7 -j);
            }
            bytes[i] = transByte;
        }
    }

　　經驗證，將8位元的byte進行位置反轉，能夠完美匹配兩種資料結構。

　　如此一來，就可以輕鬆將整個bitmap進行初始化設定到redis中，從而在redis的bitmap中，使用 getbit 進行高效判定了。