LetsCoding.cn

 IndexInput/IndexOutput類系

綜述：Lucene在存儲和讀取索引的時候，把文件內容都當作字節來對待。Int型拆分成1-5個byte分別存儲；float則拆分成1-10個byte分別存儲。Char型拆分成1-3個byte來存儲。

1． IndexInput/IndexOutput類系的層次圖

其中，FSDirectory.FSIndexInput和FSDirectory.FSIndexOutput是FSDirectory的內部類(protected static)。

2.部分代碼說明

IndexInput/IndexOutput類

在綜述里說過，Lucene把文本都以字節為單位進行處理。下面是IndexInput/IndexOutput部分方法的代碼清單，從中我們能清楚的理解Lucene的文本處理方式。

writeInt(int)方法把int型變量處理成4個字節，從高位到低位分別存儲。

1    public void writeInt(int i) throws IOException {
2        writeByte((byte) (i >> 24));    // 寫高8位
3        writeByte((byte) (i >> 16));    // 寫次高8位
4        writeByte((byte) (i >> 8));        // 寫次次高8位
5        writeByte((byte) i);    //寫低8位
6    }

writeVInt(int)方法把int型變量處理成1-5個字節，從低位到高位分別存儲。值小的，占用的字節數就少；值大的，占用的字節數就多。這個就是Lucene壓縮存儲的基石了。

1    public void writeVInt(int i) throws IOException {
2        while ((i & ~0x7F) != 0) {    // 當最高位不為0，執行循環體
3            writeByte((byte) ((i & 0x7f) | 0x80));    // 寫入低7位，最高位置1
4            i >>>= 7;    // 向右偏移7位，也就是往高位移動7位
5        }
6        writeByte((byte) i);    // 寫入數據最高位（肯定不足7位了），最高位顯然是0
7    }

IndexInput中的readInt()和readVInt()用來讀取文件內容。

readInt()在讀取時，把讀取的4個字節從高位到底位依次拼接。這一點在下面的代碼中可以很容易看出來。

1    public int readInt() throws IOException {
2        return ((readByte() & 0xFF) << 24) | ((readByte() & 0xFF) << 16)
3                | ((readByte() & 0xFF) << 8) | (readByte() & 0xFF);
4    }

readVInt()稍微有點復雜,它的讀取順序是由低位到高位，步驟如下：

(1).讀入一個字節存入變量b
(2).b取后7位，存入變量i；若b首位是0，則返回i
(3).讀取下個字節存入b，b往左偏移7*(n-1)位后與i拼接后存入i，轉到(2)

注：
A．n為循環次數
B．其實只要理解了writeVInt(int)的寫入方式后，readVInt()就不難理解了。

下面是readVInt()的代碼清單：

1    public int readVInt() throws IOException {
2        byte b = readByte(); // 讀取第一個字節
3        int i = b & 0x7F; // 取后7位
4        for (int shift = 7; (b & 0x80) != 0; shift += 7) { // 當該字節首位不為0，執行循環體
5            b = readByte(); // 讀取下個字節
6            i |= (b & 0x7F) << shift; // 取該字節后7位，偏移到高位，跟原i值拼接
7        }
8        return i;
9    }

至于writeLong(long)，它在形式上把long拆成2個int來處理；writeVLong(long)/readVLong()思路（代碼）跟writeVInt(int)/readVLong()除了方法名之外，完全一樣；realLong()通過兩次readInt()，第一個值偏移32位后拼接第二個值。

writeChars(char[],int,int)用來把一個符合UTF-8編碼的字符數組寫入文件，它同樣把字符拆分成字節來對待。對每個字符，按照其有效位數n（去掉高位的0）的不同，采用有三種不同的寫入方法：

(1).0< n <=7，取后7位，首位置0寫入文件
(2).7< n <=11或者n=0，取高1-5位，首3位置110；取后6位，首2位置10；寫入文件
(3).11< n <=16,取高0-4位，首4位置1110；取中6位，首2位置10；取后6位，首2位置10；寫入文件

其代碼及注釋如下:

 1    public void writeChars(char[] s, int start, int length) throws IOException {
 2        // start為開始的字符在char[]中的位置，length為需要寫的字符的個數
 3        final int end = start + length;
 4        for (int i = start; i < end; i++) {    // 循環遍歷char[]中從start到end的字符
 5            final int code = (int) s[i];
 6            if (code >= 0x01 && code <= 0x7F) 
 7                // code值在0x01-0x7F，直接寫入
 8                // code的有效位數為1-7位
 9                writeByte((byte) code);
10            else if (((code >= 0x80) && (code <= 0x7FF)) || code == 0) {
11                // code值在0x80-0x7FF或者為0，則分兩個字節寫入
12                // code的有效位數8-11位
13                writeByte((byte) (0xC0 | (code >> 6)));     // 寫高2-5位，首3位置110
14                writeByte((byte) (0x80 | (code & 0x3F)));    // 寫低6位，首2位置10
15            } else {
16                //0x7FF之后的用3個字節寫入，code有效位數12-16位
17                writeByte((byte) (0xE0 | (code >>> 12)));    // 寫高0-4位，首4位置1110
18                writeByte((byte) (0x80 | ((code >> 6) & 0x3F)));    //寫此高位6位，首2位置10
19                writeByte((byte) (0x80 | (code & 0x3F)));        //寫低6位，首2位置10
20            }
21        }
22    }

writeChars(String, int, int)思路（代碼）跟上面是一樣的。

與writeChars(char[], int, int)對應的readChars(char[], int, int)代碼及注釋如下：

 1    public void readChars(char[] buffer, int start, int length)
 2            throws IOException {
 3        final int end = start + length;
 4        for (int i = start; i < end; i++) {
 5            byte b = readByte(); // 讀取一個字節
 6            if ((b & 0x80) == 0) // 如果首位不為1，說明該字節單獨為一字符
 7                buffer[i] = (char) (b & 0x7F);
 8            else if ((b & 0xE0) != 0xE0) { // 首4位不為1110
 9                buffer[i] = (char) (((b & 0x1F) << 6) | (readByte() & 0x3F));
10            } else {
11                buffer[i] = (char) (((b & 0x0F) << 12)
12                        | ((readByte() & 0x3F) << 6) | (readByte() & 0x3F));
13            }
14        }
15    }

 writeString(String)用來寫入字符串。它先寫入該字符串的長度，然后調用writeChars(String, int, int)寫入字符串。代碼及注釋如下：

1    public void writeString(String s) throws IOException {
2        int length = s.length();    // 字符串長度
3        writeVInt(length);    // 寫入字符串長度
4        writeChars(s, 0, length);    //寫入字符串
5    }

 readString()在讀取的時候利用了IndexInput類的私有變量(private char[] chars)來緩存字符串，唯一需要注意的就是在需要時，要給char擴充容量。代碼及注釋如下：

    public String readString() throws IOException {
        int length = readVInt();
        if (chars == null || length > chars.length)    // 需要時，給chars擴容
            chars = new char[length];
        readChars(chars, 0, length);
        return new String(chars, 0, length);
    }

BufferedIndexInput/BufferedIndexOutput類

BufferedIndexInput/BufferedIndexOutput依然是抽象類，它們給出了部分IndexInput/IndexOutput未曾實現的抽象方法，如getFilePointer()，writeByte()/readByte()等等。還提供了writeBytes()/readBytes()這樣的在索引優化合并時使用的方法。

BufferedIndexOutput中的變量說明：

1    static final int BUFFER_SIZE = 16384;    // buffer的總容量
2
3    private final byte[] buffer = new byte[BUFFER_SIZE];    // 用于寫文件時的緩沖區
4    private long bufferStart = 0; // position in file of buffer:  buffer 在文件中的偏移量
5    private int bufferPosition = 0; // position in buffer : 在buffer中的偏移量

writeByte(byte)為往buffer中寫入byte，代碼比較簡單，如下：

1    public void writeByte(byte b) throws IOException {
2        if (bufferPosition >= BUFFER_SIZE)    // 注意buffer裝滿時需要flush()
3            flush();
4        buffer[bufferPosition++] = b;    
5    }

 writeBytes(byte[], int, int)從名字就知道是存儲一個byte數組。代碼及注釋如下：

 1    public void writeBytes(byte[] b, int offset, int length) throws IOException {    // 該方法在索引優化合并時使用
 2        // offset: 首個字節在b中的位置；    length: 序列長度（字節數）
 3        int bytesLeft = BUFFER_SIZE - bufferPosition;    // bytesLeft: buffer剩余容量
 4        // is there enough space in the buffer?
 5        if (bytesLeft >= length) {    // 剩余容量可以放下長度length的字節數
 6            // we add the data to the end of the buffer
 7            System.arraycopy(b, offset, buffer, bufferPosition, length);
 8            bufferPosition += length;
 9            // if the buffer is full, flush it
10            if (BUFFER_SIZE - bufferPosition == 0)
11                flush();
12         } else {    // 剩余容量放不下
13            // is data larger then buffer?
14             if (length > BUFFER_SIZE) {    // BUFFER_SIZE < length 時
15                // we flush the buffer
16                if (bufferPosition > 0)
17                    flush();
18                // and write data at once
19                flushBuffer(b, offset, length);
20                bufferStart += length;
21             } else {    // bytesLeft < length < BUFFER_SIZE 時，分2次寫入
22                // we fill/flush the buffer (until the input is written)
23                int pos = 0;     // position in the input data
24                int pieceLength;    // 一次往buffer中寫入的字節數
25                while (pos < length) {    // 我仰天狂吼：為什么？為什么要用循環？！為什么？天呀，為什么你如此偏愛它？
26                    // 剩余字節數(length - pos)小于bytesLeft，pieceLength = lenght - pos，否則，pieceLength = bytesLeft
27                    pieceLength = (length - pos < bytesLeft) ? length - pos
28                            : bytesLeft;
29                    System.arraycopy(b, pos + offset, buffer, bufferPosition, pieceLength);
30                    pos += pieceLength;
31                    bufferPosition += pieceLength;    // 改變bufferPosiotion
32                    // if the buffer is full, flush it
33                    bytesLeft = BUFFER_SIZE - bufferPosition;    // 計算剩余容量
34                    if (bytesLeft == 0) {    // b裝滿則flush()
35                        flush();
36                        bytesLeft = BUFFER_SIZE;    // flush()后bytesLeft自然就要跟 BUFFER_SIZE 一樣了
37                    }
38                }
39            }
40        }
41    }

 flush()：把buffer中內容寫入文件，清空buffer。代碼及注釋如下：

1    public void flush() throws IOException {
2        flushBuffer(buffer, bufferPosition);    // buffer中的內容寫入文件
3        bufferStart += bufferPosition;    // 更改buffer在文件中的偏移量
4        bufferPosition = 0;    // buffer為空，則 bufferPosition = 0
5    }

 readByte(): 從buffer中讀取一個字節。

1    public byte readByte() throws IOException {
2        if (bufferPosition >= bufferLength)    //當前讀取位置超過buffer中內容有效長度，refill()
3            refill();
4        return buffer[bufferPosition++];
5    }

refill()：重新裝填buffer。

 1    private void refill() throws IOException {
 2        long start = bufferStart + bufferPosition; // 計算在文件中的偏移位置
 3        long end = start + bufferSize;    // 結束位置
 4        if (end > length()) // don't read past EOF： 超出文件大小
 5            end = length();
 6        int newLength = (int) (end - start);    // 能讀取的長度
 7        if (newLength <= 0)
 8            throw new IOException("read past EOF");
 9
10        if (buffer == null) {    // 需要初始化buffer
11            buffer = new byte[bufferSize]; // allocate buffer lazily
12            seekInternal(bufferStart);
13        }
14        readInternal(buffer, 0, newLength);    // 這里才是真正的裝填buffer
15        bufferLength = newLength;    // 設置buffer中有效字節數
16        bufferStart = start;    // 設置buffer在文件中的偏移量
17        bufferPosition = 0;    // 當前buffer中的偏移量
18    }

readBytes(byte[], int, int, boolean)：讀取字節數組，跟writeBytes()一樣，在索引優化合并時使用。源碼中的注釋本身已足夠清晰了，我就偷了回懶，沒寫自己的注釋，就粘過來了。

 1    public void readBytes(byte[] b, int offset, int len, boolean useBuffer)
 2            throws IOException {
 3
 4        if (len <= (bufferLength - bufferPosition)) {
 5            // the buffer contains enough data to satisfy this request
 6            if (len > 0) // to allow b to be null if len is 0
 7                System.arraycopy(buffer, bufferPosition, b, offset, len);
 8            bufferPosition += len;
 9        } else {
10            // the buffer does not have enough data. First serve all we've got.
11            int available = bufferLength - bufferPosition;
12            if (available > 0) {
13                System.arraycopy(buffer, bufferPosition, b, offset, available);
14                offset += available;
15                len -= available;
16                bufferPosition += available;
17            }
18            // and now, read the remaining 'len' bytes:
19            if (useBuffer && len < bufferSize) {
20                // If the amount left to read is small enough, and
21                // we are allowed to use our buffer, do it in the usual
22                // buffered way: fill the buffer and copy from it:
23                refill();
24                if (bufferLength < len) {
25                    // Throw an exception when refill() could not read len
26                    // bytes:
27                    System.arraycopy(buffer, 0, b, offset, bufferLength);
28                    throw new IOException("read past EOF");
29                } else {
30                    System.arraycopy(buffer, 0, b, offset, len);
31                    bufferPosition = len;
32                }
33            } else {
34                // The amount left to read is larger than the buffer
35                // or we've been asked to not use our buffer -
36                // there's no performance reason not to read it all
37                // at once. Note that unlike the previous code of
38                // this function, there is no need to do a seek
39                // here, because there's no need to reread what we
40                // had in the buffer.
41                long after = bufferStart + bufferPosition + len;
42                if (after > length())
43                    throw new IOException("read past EOF");
44                readInternal(b, offset, len);
45                bufferStart = after;
46                bufferPosition = 0;
47                bufferLength = 0; // trigger refill() on read
48            }
49        }
50    }

 FSIndexInput/FSIndexOutput類

FSIndexInput/FSIndexOutput繼承自BufferedIndexInput/BufferedIndexOutput，它最終補充實現了該類系所需提供服務的全部實現。

FSIndexOutput的flushBuffer(byte[], int, int)方法，它的功能在于真正的完成buffer到文件的數據存儲。

1        public void flushBuffer(byte[] b, int offset, int size)
2                throws IOException {
3            file.write(b, offset, size);    // 寫文件
4        }

與flushBuffer()對應的，readInternal(byte[], int, int)從底層真正的把數據從文件提取到buffer中。

 1        protected void readInternal(byte[] b, int offset, int len)    // 從文件中讀取內容到buffer
 2                throws IOException {
 3            synchronized (file) {    // file需要同步訪問
 4                long position = getFilePointer();    // 獲取當前文件讀取位置
 5                if (position != file.position) {    // file定位到當前讀取位置
 6                    file.seek(position);
 7                    file.position = position;
 8                }
 9                int total = 0;
10                do {    
11                    /**//* 一般情況下，此循環體只會執行一次，只有在第一次循環時，file中內容不能使b全部裝滿，
12                     * 這時，total < len，而下次循環，已讀到文件尾部，i = -1,拋出異常。
13                     * 也就是說，當b不能讀滿時，此方法必會拋出異常 
14                     */
15                    int i = file.read(b, offset + total, len - total);
16                    if (i == -1)
17                        throw new IOException("read past EOF");
18                    file.position += i;
19                    total += i;
20                } while (total < len);
21            }
22        }

RAMOutputStream類

RAMOutputStream繼承自IndexOutput，是用于處理在內存中建索引時的寫數據類，它在實例化是需要RAMFile類型的參數。實現了IndexOutput的writeByte()方法，也提供了在索引間拷貝數據用的writeBytes()和writeTo()方法。

writeByte()：往內存緩沖區中寫一個字節數據。

1    public void writeByte(byte b) throws IOException {    // 寫單個字節到buffer，如果當前buffer已滿，則切換到下個buffer
2        if (bufferPosition == bufferLength) {
3            currentBufferIndex++;
4            switchCurrentBuffer();    // 切換buffer
5        }
6        currentBuffer[bufferPosition++] = b;    // 寫入 b
7    }

 writeBytes():索引間拷貝數據用。

 1    public void writeBytes(byte[] b, int offset, int len) throws IOException {
 2        while (len > 0) {    // 
 3            if (bufferPosition == bufferLength) {    // 如果buffer裝滿，切換下個buffer
 4                currentBufferIndex++;
 5                switchCurrentBuffer();    // 切換buffer
 6            }
 7            
 8            int remainInBuffer = currentBuffer.length - bufferPosition;    // buffer中剩余容量
 9            int bytesToCopy = len < remainInBuffer ? len : remainInBuffer;    // 實際拷貝長度
10            System.arraycopy(b, offset, currentBuffer, bufferPosition,
11                    bytesToCopy);    // 拷貝
12            offset += bytesToCopy;    // 調整偏移量
13            len -= bytesToCopy;    // 調整長度
14            bufferPosition += bytesToCopy;    // 調整buffer中當前位置
15        }
16    }

writeTo(IndexOutput):把數據從當前內存緩沖區寫到參數指定的IndexOutput中。 

 1   public void writeTo(IndexOutput out) throws IOException {    // 拷貝整個緩沖區數據到out
 2        flush();
 3        final long end = file.length;    // file總長度
 4        long pos = 0;    // 開始偏移位置
 5        int buffer = 0;    // buffer索引
 6        while (pos < end) {
 7            int length = BUFFER_SIZE;
 8            long nextPos = pos + length;
 9            if (nextPos > end) { // at the last buffer
10                length = (int) (end - pos);
11            }
12            out.writeBytes((byte[]) file.getBuffer(buffer++), length);    // 拷貝數據
13            pos = nextPos;    // 更改偏移位置
14        }
15    }