解读Lucene.Net ——二、 InputStream 之一

其他文章：解读Lucene.Net 阅读索引

 

InputStream这个类在Java基本类库里就有，但是Lucene选择了自己来实现，翻译到dotnet版本，名称保持没变。InputStream实现了ICloneable接口，就是能支持拷贝出新对象。

 

代码2-1

        public virtual System.Object Clone()

        {

            InputStream clone = null;

            try

            {

                clone = (InputStream) this.MemberwiseClone();

            }

            catch (System.Exception e)

            {

                throw new Exception("Can't clone InputStream.", e);

            }

            if (buffer != null)

            {

                clone.buffer = new byte[BUFFER_SIZE];

                Array.Copy(buffer, 0, clone.buffer, 0, bufferLength);

            }

            clone.chars = null;

            return clone;

        }

 

从2-1代码可以看出，显示定义了一个InputStream 变量，然后用MemberwiseClone方法拷贝一个浅表副本，然后，判断如果buffer 内有数据，就把数据拷贝到浅副本里。而这个过程呢，实际上就是深拷贝。从中可以看出，浅拷贝就是克隆出新对象，但是不带数据，深拷贝呢就是浅副本带上数据。

 

InputStream 类有一个静态构造函数，给BUFFER_SIZE赋了一下值，这个值是默认buffer的大小。由OutputStream类提供，初始值是1024大小。下来在看看每个方法是干嘛的。

代码 2-2

private void  Refill()
{
    long start = bufferStart + bufferPosition;
    long end = start + BUFFER_SIZE;
    if (end > length)
    // don't read past EOF
        end = length;
    bufferLength = (int) (end - start);
    if (bufferLength == 0)
        throw new System.IO.IOException("read past EOF");
    if (buffer == null)
        buffer = new byte[BUFFER_SIZE]; // allocate buffer lazily
    ReadInternal(buffer, 0, bufferLength);
    bufferStart = start;
    bufferPosition = 0;
}

要理解Refill方法一定要看看另外三个变量。

private long bufferStart = 0; // position in file of buffer
private int bufferLength = 0; // end of valid bytes
private int bufferPosition = 0; // next byte to read

从注释上可以看到，bufferStart 代表文件缓冲区的位置，bufferLength 代表文件缓冲区的结束点，bufferPosition 表示当前读取到文件缓冲区的位置。而Refill方法也只在ReadByte方法中被使用了。

代码2-3

public byte ReadByte()
{
    if (bufferPosition >= bufferLength)
        Refill();
    return buffer[bufferPosition++];
}

可以看出，是当读取的指针达到了文件缓冲区的最大长度，才调用了Refill方法。大体上就可以猜测，Refill是用来把下一段数据载入缓冲区的。Refill为什么要在第一个语句中计算

long start = bufferStart + bufferPosition;

这个start 变量到底代表什么呢？InputStream类有一个自身的缓冲区域，private byte[] buffer;在静态构造函数中设置了这个区域的大小。而用这个类去读取文件，文件的大小一般都是大于1024字节，所以，InputStream每次读取最多1024个字节的话，在InputStream读取文件的方式就是不连续读取的，是一段一段的载入的，这个start就代表了当前读取到了文件流的位置。long end = start + BUFFER_SIZE;语句则是计算出缓冲区域相对于文件流的位置。然后判断当前缓冲区相对于文件流位置如果大于length，那么就做一个调整。在InputStream的子类RAMInputStream中，可以看到length代表了文件的总长度。这个判断就是为了限制不会超出。

bufferLength = (int) (end - start);计算出了当前缓冲区域的长度。因为读入的字节如果不满1024字节的话，实际上在任何地方都没有对buffer进行清空，因此，只能用这种方式来处理在读取的字节数小于缓冲区大小的时候，防止读取超出文件实际长度。接着用到一个ReadInternal方法，这个方法在InputStream类中是抽象方法。等讲到子类的时候再来看。

看完了Refill方法，继续关注一下ReadByte，可以看到ReadByte方法相对于是做遍历操作的，只要调用ReadByte方法，就是获取下一个字节。

代码2-4

public void  ReadBytes(byte[] b, int offset, int len)
    {
        if (len < BUFFER_SIZE)
        {
            for (int i = 0; i < len; i++)
            // read byte-by-byte
                b[i + offset] = (byte) ReadByte();
        }
        else
        {
            // read all-at-once
            long start = GetFilePointer();
            SeekInternal(start);
            ReadInternal(b, offset, len);
            bufferStart = start + len; // adjust stream variables
            bufferPosition = 0;
            bufferLength = 0; // trigger refill() on read
        }
    }

而ReadBytes方法则是一次读取指定数量的字节。如果读取的字节小于缓冲区域，则按字节读取，而如果超出了，则会先计算当前缓冲区相对文件缓冲区的位置。

代码 2-5

public long GetFilePointer()
{
    return bufferStart + bufferPosition;
}

然后SeekInternal方法也是一个抽象方法，是把读取位置跳转到指定的位置。然后用抽象方法ReadInternal实际读取。读取出的b变量因为是引用类型，所以值直接就发生了变化。

bufferLength = 0; // trigger refill() on read

把bufferLength 设置为0，则ReadByte方法一定会触发refill方法，这个注释也是这么写的。

 

代码2-6

public int ReadInt()
{
    return ((ReadByte() & 0xFF) << 24) | ((ReadByte() & 0xFF) << 16) | ((ReadByte() & 0xFF) << 8) | (ReadByte() & 0xFF);
}

ReadInt方法，用读出的每个字节和0xFF做与操作。这个用法前面也介绍到过，在.net中实际上是无必要的，这是Java和dotnet的差异造成的，翻译过来的时候译者可能并未深究。事实上在Java中也只需要 0x7F就够了，不需要0xFF。
假如ReadByte得出的值是 byte b = 244 那么 做了与操作之后还是244。左移24位，244的2进制是1111 1010，就是在后面加 24个0，位数就变成了32位。后面的操作和这个类似，做了或操作，相当于是把ReadByte读取到的4个byte值，排列得到一个数字。因为数字是32位，所以只要这个byte值是大于127的，都会产生负数。因为int类型的最高位是代表符号的，127的2进制是0111 1111，左移24位，最高位是0，而如果是128，就会变成 1111 1111    1000 0000，自然就变成了负数了。这个方法读取了4个字节。

代码2-7

public int ReadVInt()
{
    byte b = ReadByte();
    int i = b & 0x7F;
    for (int shift = 7; (b & 0x80) != 0; shift += 7)
    {
        b = ReadByte();
        i |= (b & 0x7F) << shift;
    }
    return i;
}

和ReadInt相比，运算的方式和ReadInt相似，但也有差别，每次位移是7位。

 

代码2-8

public long ReadLong()
{
    return (((long) ReadInt()) << 32) | (ReadInt() & 0xFFFFFFFFL);
}

ReadLong方法读取了8个字节。对比看看ReadLong方法和ReadVInt方法有什么区别。ReadVInt方法每次位移的是7位的整数倍，那是因为

int i = b & 0x7F;

操作得到的值不会大于127，而这个值得2进制是0111 1111，把最高位的0省略，那么就是7个1。这样第一次没有位移，而第二次位移7位，相当于在第一次读取字节二进制的高位加上了第二读取的字节。一直循环N次，加上第一次，就是N+1次。而ReadLong则是和ReadInt方法一样的，把后面得到的字节放在低位。ReadVInt方法相当于把ReadLong方法的高位和低位调换了，这在系统中比较常见，Socket就是这么做的，做过游戏外挂的肯定都知道这个的。

 

代码 2- 9

public long ReadVLong()
{
    byte b = ReadByte();
    long i = b & 0x7F;
    for (int shift = 7; (b & 0x80) != 0; shift += 7)
    {
        b = ReadByte();
        i |= (b & 0x7FL) << shift;
    }
    return i;
}

对比以上的理解就很容易理解ReadVLong方法了，和ReadVInt类似。ReadVLong，ReadVInt循环中的条件是(b & 0x80) != 0，0x80就是 1000 0000，所以一旦读取到b是1000 0000以上的数值，这个循环就终止了。也就是当b >= 128 。当然在java版本中和这个有差异，因为java的byte是 -128 - 127，所以，byte的最高位是符号，那么这个地方就是小于0的意思。

 

代码 2- 10

public System.String ReadString()
    {
        int length = ReadVInt();
        if (chars == null || length > chars.Length)
            chars = new char[length];
        ReadChars(chars, 0, length);
        return new System.String(chars, 0, length);
    }

ReadString方法，在第一次运行时候，会设置为整个文件的长度，然后读取出了整个文件的字符。

代码 2-11

public void  ReadChars(char[] buffer, int start, int length)
    {
        int end = start + length;
        for (int i = start; i < end; i++)
        {
            byte b = ReadByte();
            if ((b & 0x80) == 0)
                buffer[i] = (char) (b & 0x7F);
            else if ((b & 0xE0) != 0xE0)
            {
                buffer[i] = (char) (((b & 0x1F) << 6) | (ReadByte() & 0x3F));
            }
            else
                buffer[i] = (char) (((b & 0x0F) << 12) | ((ReadByte() & 0x3F) << 6) | (ReadByte() & 0x3F));
        }
    }

ReadChars方法在ReadString方法中就是用来读取文件的全部字符的。

其他方法都比较简单，就不用细看了。至于这里为什么要这样来读取，那就要看OutputStream类了。呵呵。