Lucene源代码之SegmentInfo

 首先还是来看看，SegmentInfo到底是干什么的吧：

Segmentinfo是保存在SegmentInfos容器里面，它主要是记录每个segment的情况。还要引用前面的Segments_N文件格式图：

 

看到里面两个大的虚线框了吗，每一个虚线框就表示一个segment，里面的信息就是SegmentInfo需要处理（保存、写入）的数据，也就是它的属性，具体有SegName、SegSize、DelGen、HasSingleNormFile、NumField、NormGen[]数组以及IsCompoundFile。

SegmentInfo类所要做的事情有：

1，对每个Field的norm文件进行处理：设置该norm文件的gen；

2，使用write()方法，将一个处理过的Segments文件写入索引目录；

3，根据getNormFileName(int number)方法， 通过一个索引段文件的索引值number，可以得到它的norm文件的gen值，这个gen值其实就是这个segments的gen，即形如segments_N形式，N=gen。

4，获取索引目录下存在的不同扩展名的文件，可以分出下面几组：

(1) 如果useCompoundFile=true，获取到扩展名为.cfs的复合文件；

(2) 如果useCompoundFile=false，获取到扩展名为如下的复合文件：

fnm、fdx、fdt、tii、tis、frq、prx、tvx、tvd、tvf、nrm；

(3) 如果是删除文件，获取到扩展名为.del的文件，若name="segments"，delGen=6，则文件名形如segments_6.del；

(4) 如果normGen != null且normGen[i] >0，获取到扩展名为.sX的文件，若name="segments"，gen=6，i=X=8，则该类文件形如segments_6.s8；

(5) 如果normGen != null且normGen[i] =-1且hasSingleNormFile=false且useCompoundFile=false，获取到扩展名为.fX的文件，若name="segments"，gen=6，i=X=8，则该类文件形如segments_6.f8；

(6) 如果normGen != null且normGen[i] =0且useCompoundFile=true，获取到扩展名为.sX的文件，若name="segments"，i=X=8，则该类文件形如segments.s8；

(7) 如果normGen != null且normGen[i] =0且hasSingleNormFile=false且useCompoundFile=false，获取到扩展名为.fX的文件，若name="segments"，i=X=8，则该类文件形如segments.f8；

(8) 如果normGen == null的时候，preLockless = true或(||)(hasSingleNormFile=false且useCompoundFile=false)，这时若useCompoundFile=true，则获取到扩展名为.s的文件，若name="segments"，则该类文件形如segments.s；

(9) 如果normGen == null的时候，preLockless = true或(||)(hasSingleNormFile=false且useCompoundFile=false)，这时若useCompoundFile=false，则获取到扩展名为.f的文件，若name="segments"，则该类文件形如segments.f；

详细内容看下面剖析SegmentInfo源码：

1. package org.apache.lucene.index;
3. import org.apache.lucene.store.Directory;
4. import org.apache.lucene.store.IndexOutput;
5. import org.apache.lucene.store.IndexInput;
6. import java.io.IOException;
8. final class SegmentInfo {
9.   public String name;                 // unique name in dir
10.   public int docCount;                // number of docs in seg
11.   public Directory dir;               // where segment resides
13.   private boolean preLockless;    // 为true，当一个索引段文件在无锁提交之前被写入
15.   private long delGen;     // 当前版本(generation)删除时的gen的值为delGen(即segments_delGen.del)
16.    
17.   private long[] normGen;    //   每个Field对应的norm文件的gen                                                
18.          
19.   private byte isCompoundFile;    // 如果为0，则表示不用检查；如果为1表示检查是否存在2.1版本之前的扩展名为.cfs和.nrm的文件                        
21.   private boolean hasSingleNormFile;   //如果一个segments存在一个单独的norm文件。在当前版本中，false表示一个segments是由DocumentWriter生成的，true表示为最新创建的合并的索引段文件(包括复合segments文件和非复合segments文件)
22.   
23.   public SegmentInfo(String name, int docCount, Directory dir) {
24.     this.name = name;
25.     this.docCount = docCount;
26.     this.dir = dir;
27.     delGen = -1;// 初始化一个SegmentInfo的时候，指定存在标准化因子.nrm文件，和.del文件
28.     isCompoundFile = 0;
29.     preLockless = true;
30.     hasSingleNormFile = false;
31.   }
33.   public SegmentInfo(String name, int docCount, Directory dir, boolean isCompoundFile, boolean hasSingleNormFile) { 
34.     this(name, docCount, dir);
35.     this.isCompoundFile = (byte) (isCompoundFile ? 1 : -1);
36.     this.hasSingleNormFile = hasSingleNormFile;
37.     preLockless = false; // 为false，当一个索引段文件不是在无锁提交之前被写入
38.   }
40.   /**
41.    *  根据指定的SegvmentInfo，拷贝它到我们当前的SegmentInfo实例中，
42.    *  其实就是重新构造一个SegmentInfo，重新构造的该SegmentInfo与指
43.    *  定的SegmentInfo src是相同的
44.    */
45.   void reset(SegmentInfo src) {
46.     name = src.name;
47.     docCount = src.docCount;
48.     dir = src.dir;
49.     preLockless = src.preLockless;
50.     delGen = src.delGen;
51.     if (src.normGen == null) {
52.       normGen = null;
53.     } else {
54.       normGen = new long[src.normGen.length];
55.       System.arraycopy(src.normGen, 0, normGen, 0, src.normGen.length);
56.     }
57.     isCompoundFile = src.isCompoundFile;
58.     hasSingleNormFile = src.hasSingleNormFile;
59.   }
61.   /**
62.     构造一个SegmentInfo对象，通过构造一个索引输入流对象IndexInput
63.    */
64.   public SegmentInfo(Directory dir, int format, IndexInput input) throws IOException {
65.     this.dir = dir;
66.     name = input.readString();
67.     docCount = input.readInt();
68.     if (format <= SegmentInfos.FORMAT_LOCKLESS) {
69.       delGen = input.readLong();
70.       if (format <= SegmentInfos.FORMAT_SINGLE_NORM_FILE) {
71.         hasSingleNormFile = (1 == input.readByte());
72.       } else {
73.         hasSingleNormFile = false;
74.       }
75.       int numNormGen = input.readInt();
76.       if (numNormGen == -1) {
77.         normGen = null;
78.       } else {
79.         normGen = new long[numNormGen];
80.         for(int j=0;j<numNormGen;j++) {
81.           normGen[j] = input.readLong();
82.         }
83.       }
84.       isCompoundFile = input.readByte();
85.       preLockless = isCompoundFile == 0;
86.     } else {
87.       delGen = 0;
88.       normGen = null;
89.       isCompoundFile = 0;
90.       preLockless = true;
91.       hasSingleNormFile = false;
92.     }
93.   }
94.   
95.   /**
96.    * 为每个Field的norm文件设置gen值（相当于初始化）
97.    */
98.   void setNumFields(int numFields) {
99.     if (normGen == null) {
100.       // normGen is null if we loaded a pre-2.1 segment
101.       // file, or, if this segments file hasn't had any
102.       // norms set against it yet:
103.       normGen = new long[numFields];
105.       if (!preLockless) {
106.         // This is a FORMAT_LOCKLESS segment, which means
107.         // there are no norms:
108.         for(int i=0;i<numFields;i++) {
109.           normGen[i] = -1;
110.         }
111.       }
112.     }
113.   }
115.   boolean hasDeletions()
116.     throws IOException {
117.     // Cases:
118.       
119.     //   delGen == -1: this means this segment was written
120.     //     by the LOCKLESS code and for certain does not have
121.     //     deletions yet
122.     //
123.     //   delGen == 0: this means this segment was written by
124.     //     pre-LOCKLESS code（无锁提交之前模式） which means we must check
125.     //     directory to see if .del file exists
126.     //
127.     //   delGen > 0: this means this segment was written by
128.     //     the LOCKLESS code（无锁提交模式） and for certain has
129.     //     deletions
130.     //
131.     if (delGen == -1) {
132.       return false;
133.     } else if (delGen > 0) {
134.       return true;
135.     } else {
136.       return dir.fileExists(getDelFileName());
137.       // getDelFileName()在后面定义了该方法，获取删除的该索引目录下的文件名
138.     }
139.   }
141.   void advanceDelGen() {
142.     // delGen 0 is reserved for pre-LOCKLESS format
143.     if (delGen == -1) {
144.       delGen = 1;
145.     } else {
146.       delGen++;
147.     }
148.   }
150.   void clearDelGen() {
151.     delGen = -1;
152.   }
154.   public Object clone () {
155.     SegmentInfo si = new SegmentInfo(name, docCount, dir);
156.     si.isCompoundFile = isCompoundFile;
157.     si.delGen = delGen;
158.     si.preLockless = preLockless;
159.     si.hasSingleNormFile = hasSingleNormFile;
160.     if (normGen != null) {
161.       si.normGen = (long[]) normGen.clone();
162.     }
163.     return si;
164.   }
166.   /**
167.    * 获取删除的该索引目录下的文件名
168.    */
169.   String getDelFileName() {
170.     if (delGen == -1) {
171.       // In this case we know there is no deletion filename
172.       // against this segment
173.       return null;
174.     } else {
175.       // If delGen is 0, it's the pre-lockless-commit file format
176.       return IndexFileNames.fileNameFromGeneration(name, ".del", delGen);
177.       // 即返回文件名为name_delGen.del，例如segments_5.del
178.     }
179.   }
181.   /**
182.    * Returns true if this field for this segment has saved a separate norms file (_<segment>_N.sX).
183.    * 如果该索引段的这个Field作为separate norms文件(_<segment>_N.sX)进行存储
184.    *
185.    * fieldNumber是一个需要检查的field的索引
186.    */
187.   boolean hasSeparateNorms(int fieldNumber)
188.     throws IOException {
189.       /**
190.        * 不了解为什么使用normGen == null && preLockless作为判断条件
191.        * 应该是preLockless为true表示有norm文件，why？
192.        */
193.     if ((normGen == null && preLockless) || (normGen != null && normGen[fieldNumber] == 0)) {
194.       // Must fall back to directory file exists check:
195.       String fileName = name + ".s" + fieldNumber;
196.       return dir.fileExists(fileName);
197.     } else if (normGen == null || normGen[fieldNumber] == -1) {
198.       return false;
199.     } else {
200.       return true;
201.     }
202.   }
204.   /**
205.    * Returns true if any fields in this segment have separate norms.
206.    */
207.   boolean hasSeparateNorms()
208.     throws IOException {
209.     if (normGen == null) {
210.       if (!preLockless) {
211.         // This means we were created w/ LOCKLESS code and no
212.         // norms are written yet:
213.         return false;
214.       } else {
215.         // This means this segment was saved with pre-LOCKLESS
216.         // code.  So we must fall back to the original
217.         // directory list check:
218.         // segment使用pre-LOCKLESS模式保存，需要回退到最初的目录下，进行核查
219.         String[] result = dir.list();
220.         String pattern;
221.         pattern = name + ".s";
222.         int patternLength = pattern.length();
223.         for(int i = 0; i < result.length; i++){
224.           if(result[i].startsWith(pattern) && Character.isDigit(result[i].charAt(patternLength)))
225.             return true;
226.         }
227.         return false;
228.       }
229.     } else {
230.       // NormGen!=NULL
231.       // This means this segment was saved with LOCKLESS
232.       // code so we first check whether any normGen's are >
233.       // 0 (meaning they definitely have separate norms):
234.       // 检查是否任何一个normGen都是 >= 1的
235.       for(int i=0;i<normGen.length;i++) {
236.         if (normGen[i] > 0) {
237.           return true;
238.         }
239.       }
240.       // Next we look for any == 0.  These cases were
241.       // pre-LOCKLESS and must be checked in directory:
242.       for(int i=0;i<normGen.length;i++) {
243.         if (normGen[i] == 0) {
244.           if (hasSeparateNorms(i)) {
245.             return true;
246.           }
247.         }
248.       }
249.     }
251.     return false;
252.   }
254.   /**
255.    * Increment the generation count for the norms file for
256.    * this field.
257.    * 为每个Field的norm文件的gen，执行加1操作
258.    * 
259.    * @param fieldIndex：指定的Field的norm文件需要被重写，
260.    * fieldIndex即对应的norm文件的gen值
261.    */
262.   void advanceNormGen(int fieldIndex) {
263.     if (normGen[fieldIndex] == -1) {
264.       normGen[fieldIndex] = 1;
265.     } else {
266.       normGen[fieldIndex]++;
267.     }
268.   }
270.   /**
271.    * Get the file name for the norms file for this field.
272.    *
273.    * @param number field index;number是一个Field的索引值
274.    */
275.   String getNormFileName(int number) throws IOException {
276.     String prefix;
278.     long gen;
279.     if (normGen == null) {
280.       gen = 0;
281.     } else {
282.       gen = normGen[number];//根据Field的索引值获取它对应的norm文件的gen值，然后使用该gen值取得索引段文件的文件名
284.     }
285.     
286.     if (hasSeparateNorms(number)) {
287.       // case 1: separate norm
288.       prefix = ".s";
289.       return IndexFileNames.fileNameFromGeneration(name, prefix + number, gen);
290.       //使用gen值取得索引段文件的文件名，如果name=“segments”，number=7，gen=4，则返回的文件名为segments_4.s7
291.     }
293.     if (hasSingleNormFile) { //   如果存在一个单独的norm文件
294.       // case 2: lockless (or nrm file exists) - single file for all norms 
295.       prefix = "." + IndexFileNames.NORMS_EXTENSION;
296.       // IndexFileNames.NORMS_EXTENSION=nrm
297.       return IndexFileNames.fileNameFromGeneration(name, prefix, 0);
298.       // 如果name=“segments”，则返回的文件名为segments.nrm 
299.     }
300.       
301.       // case 3: norm file for each field
302.     prefix = ".f";
303.     return IndexFileNames.fileNameFromGeneration(name, prefix + number, 0);
304.       //  如果name=“segments”，number=7，则返回的文件名为segments.f7
306.   }
308.   /**
309.    * Mark whether this segment is stored as a compound file.
310.    *
311.    * @param isCompoundFile true if this is a compound file;
312.    * else, false
313.    */
314.   void setUseCompoundFile(boolean isCompoundFile) {
315.     if (isCompoundFile) {
316.       this.isCompoundFile = 1;
317.     } else {
318.       this.isCompoundFile = -1;
319.     }
320.   }
322.   /**
323.    * Returns true if this segment is stored as a compound
324.    * file; else, false.
325.    */
326.   boolean getUseCompoundFile() throws IOException {
327.     if (isCompoundFile == -1) {
328.       return false;
329.     } else if (isCompoundFile == 1) {
330.       return true;
331.     } else {
332.       return dir.fileExists(name + ".cfs");
333.     }
334.   }
335.   
336.   /**
337.    * Save this segment's info.
338.    * 
339.    * 保存segment的信息，其实就是输出(写入)到磁盘中的索引目录中
340.    */
341.   void write(IndexOutput output)
342.     throws IOException {
343.     output.writeString(name);
344.     output.writeInt(docCount);
345.     output.writeLong(delGen);
346.     output.writeByte((byte) (hasSingleNormFile ? 1:0));
347.     if (normGen == null) {
348.       output.writeInt(-1);
349.     } else {
350.       output.writeInt(normGen.length);
351.       for(int j = 0; j < normGen.length; j++) {
352.         output.writeLong(normGen[j]);
353.       }
354.     }
355.     output.writeByte(isCompoundFile);
356.   }
357. }

我现在看得是lucene2.1.0版本，恰好是segmentinfo类更新的分界点。原来的版本里面的SegmentInfo类的实现非常简单。

1. package org.apache.lucene.index;
3. import org.apache.lucene.store.Directory;
5. final class SegmentInfo {
6. public String name;      // unique name in dir
7. public int docCount;      // number of docs in seg
8. public Directory dir;      // where segment resides
10. public SegmentInfo(String name, int docCount, Directory dir) {
11.     this.name = name;
12.     this.docCount = docCount;
13.     this.dir = dir;
14. }
15. }

Lucene2.1及其以后的版本，SegmentInfo类的实现就变得比较复杂了。尤其在写入Norm文件这方面。下面就罗列版本前后的一些差别：

【在2.1之前的版本，存在下面的一些格式的文件】

在每个Document逻辑文件中，对于一个被索引的Field，都对应着一个norm文件，该norm文件的一个字节与Document有非常密切的关系。

这个.f[0-9]*文件，是为每个Document设置的，当Document中的一个Field被命中的时候，.f[0-9]*文件包含的就是：一个字节编码值乘以排序分值。

一个单独的norm文件的创建，仅仅是在一个复合segments文件被创建的时候才存在。即：一个单独的norm文件的存在是依赖于复合segments的，如果复合segments文件不存在，就不会生成一个单独的norm文件。

 

【在2.1版本及其之后的版本，存在下面的一些格式的文件】

只使用一个.nrm文件，该文件包含了所有的标准化因子。所有的.nrm文件都包含NormsHeader和<Norms> ^{NumFieldsWithNorms} 这两部分。

其中：

NormsHeader包含4个字节，前三个字节为“N”、“R”、“M”，最后一个字节指定了FORMAT版本号，当前因为是2.2.0版本，版本号为-1，可以在SegmentInfos类的定义开始部分看到：

public static final int FORMAT = -1;

<Norms>对应这一个<Byte>，而^{NumFieldsWithNorms} 对应于一个Segments的大小，即^SegSize。

一个.nrm文件的每个字节都编码成一个浮点值，该字节的前3bits(即0-2)表示尾数，后5bits(即3-7)表示指数。

当一个已经存在segments文件的标准化因子值(即norm的value)被修改，同时一个单独的norm文件被创建；当Field N被修改，同时一个.sN文件被创建，这个.sN文件用来保存该Field的标准化因子值(即norm的value)。

当适当的时候，一个单独的norm文件的创建，可以是为了一个复合segments文件，也可以不是复合segments文件。

【小结】

2.1版本以前的，norm文件的形式有：segments.fN、segments_N.sX两种。其中N是gen值，X是一个Field在Document中的索引值。

2.1版本以后的，norm文件只使用一个.nrm扩展名的文件来代替以前的norm文件，则这个文件就是segments.nrm文件，并且对于同一个索引段，只有一个segments.nrm文件。

2.1版本以后的，统一使用一个.nrm文件，该文件包含了所有的标准化因子，因为需要对2.1版本以前的版本进行支持，需要处理2.1版本之前的一些版本中，对标准化因子设置文件进行处理。