纯真IP库的结构分析及一个查询类

  个人网站上有个功能，记录访问者的IP及其归属地。最初我偷懒通过一个WebService来查询IP归属地，后来觉得通过这种方法响应时间长，资源耗费大，而且对那个WebSerice的依赖度太高，如果它挂了或者网络原因，经常要到超时才返回。所以，我打算直接从本地的纯真IP库里查询。

    纯真库的数据结构在http://lumaqq.linuxsir.org/article/qqwry_format_detail.html上讲的很详细了。简单地讲数据文件分成三个区域：
    1、文件头（8个字节，前4字节是指向索引区第一条记录，后4字节指向索引区最后一条记录）
    2、记录区(一个记录包含IP地址，国家记录，地区记录，后两个记录有可能是字符串，也可能是重定向,有多种重定向模式)
    3、索引区（一个索引定长7个字节，前4字节是IP地址（little-endian），后3字节指向对应记录区的位置，这里的位置指从文件头开始计算的偏移字节）

   虽然这个库结构工作的很好，效率也没有问题，但是我觉得设计的有点小复杂了。而且，如果记录区中有条记录A，是重定向到记录B中的，假如我删除了记录B，查询记录A的时候就会有问题。当然，可以在删除记录B的时候进行相应处理，只是有些麻烦。如果把文件结构改成如下，应该处理起来会更方便一些：
   1、文件头（与原库一样）
   2、字符串区
   3、索引区（4字节的IP地址，4字节的偏移值，4字节的偏移值）
所有字符串放在字符串区中，统一管理。索引区中放IP地址，国家记录的“指针”和区域记录的“指针”，所谓的“指针”是对应到字符串区中某条的字符串偏移值。

不过既然纯真IP库是这么设计的，我只好根据它的结构来进行相应的查询。

索引区的记录是从小到大排列的，可以用二分法来查询。
IP库中索引的IP地址，并不是连续的，举个例子，192.168.0.0的后一条记录并不是192.168.0.1，可能是192.169.0.0，也就是说，它存储的一个是IP段。所以要做一个类似于“四舍五入”的处理。好在大部分情况下，我们都只要舍掉就可以了，比如查询192.168.1.1应该匹配192.168.0.0而不是192.169.0.0。

1. import java.io.*; 
2.  
3. public class IPSeeker 
4. { 
5.     protected RandomAccessFile ipDataFile; 
6.     protected final int RECORD_LEN = 7; 
7.     protected final int MODE_1 = 0x01; //重定向国家记录，地区记录 
8.     protected final int MODE_2 = 0x02; //重定向国家记录，有地区记录 
9.     protected final int MODE_3 = 0x03; //default 
10.     protected long indexBegin; 
11.     protected long indexEnd; 
12.          
13.     public IPSeeker() throws Exception 
14.     { 
15.         //打开纯真IP库数据文件 
16.         ipDataFile = new RandomAccessFile("qqwry.dat", "r"); 
17.          
18.         indexBegin = readLong(4, 0);             
19.         indexEnd = readLong(4, 4); 
20.     } 
21.      
22.     public static void main(String[] args) throws Exception 
23.     { 
24.         IPSeeker seeker = new IPSeeker();//may throw Exception 
25.         String result = seeker.search("111.2.13.4");//输入查询的IP地址 
26.         System.out.println(result); 
27.         seeker.close();//关闭,若不调用close，将在finalize关闭 
28.         seeker = null; 
29.     } 
30.      
31.      
32.     @Override 
33.     protected void finalize() throws Throwable 
34.     { 
35.         try 
36.         { 
37.             ipDataFile.close(); 
38.         }  
39.         catch (IOException e) 
40.         { 
41.              
42.         } 
43.         super.finalize(); 
44.     } 
45.      
46.      
47.     public void close() 
48.     { 
49.         try 
50.         { 
51.             ipDataFile.close(); 
52.         }  
53.         catch (IOException e) 
54.         { 
55.              
56.         } 
57.     } 
58.  
59.     public String search(String ipStr) throws Exception 
60.     { 
61.         //采用二分法查询 
62.         long recordCount = (indexEnd - indexBegin) / 7 + 1; 
63.          
64.         long itemStart = 0; 
65.         long itemEnd = recordCount - 1; 
66.         long ip = IPSeeker.stringIP2Long(ipStr); 
67.         long middle = 0; 
68.         long midIP = 0; 
69.         while(itemStart <= itemEnd) 
70.         { 
71.             middle = (itemStart +  itemEnd) / 2; 
72.             midIP = readLong(4, indexBegin + middle * 7); 
73.             //String temp = IPSeeker.long2StringIP(midIP); 
74.             if(midIP == ip) 
75.             { 
76.                 break; 
77.             } 
78.             else if(midIP < ip) 
79.             { 
80.                 itemStart = middle + 1; 
81.             } 
82.             else//midIP > ip 
83.             { 
84.                 itemEnd = middle - 1; 
85.             } 
86.         } 
87.          
88.         //若无完全匹配结果，则向前匹配 
89.         if(ip < midIP && middle > 0) 
90.         { 
91.             middle--; 
92.         } 
93.  
94.         long item = readLong(3, indexBegin + middle * 7 + 4); 
95.         String[] result = getInfo(item + 4);//取出信息 
96.         return long2StringIP(readLong(4, indexBegin + middle * 7))+ ","//匹配到的IP地址(段) 
97.                 + result[0] + "," //国家 
98.                 + result[1];//地区 
99.     } 
100.      
101.     //32位整型格式的IP地址(little-endian)转化到字符串格式的IP地址 
102.     public static String long2StringIP(long ip) 
103.     { 
104.         long ip4 = ip >> 0 & 0x000000FF; 
105.         long ip3 = ip >> 8 & 0x000000FF; 
106.         long ip2 = ip >> 16 & 0x000000FF; 
107.         long ip1 = ip >> 24 & 0x000000FF; 
108.          
109.         return String.valueOf(ip1) + "." + String.valueOf(ip2) + "." +  
110.                 String.valueOf(ip3) + "." + String.valueOf(ip4); 
111.     } 
112.      
113.     //字符串格式的IP地址转化到32位整型格式的IP地址(little-endian) 
114.     public static Long stringIP2Long(String ipStr) throws Exception 
115.     { 
116.         String[] list = ipStr.split("\\."); 
117.         if(list.length != 4) 
118.         { 
119.             throw new Exception("IP地址格式错误"); 
120.         } 
121.         long ip = Long.parseLong(list[0]) << 24 & 0xFF000000; 
122.         ip += Long.parseLong(list[1]) << 16 & 0x00FF0000; 
123.         ip += Long.parseLong(list[2]) << 8 & 0x0000FF00; 
124.         ip += Long.parseLong(list[3]) << 0 & 0x000000FF; 
125.         return ip; 
126.     } 
127.      
128.     //读取一个n位的 
129.     private long readLong(int nByte, long offset) throws Exception 
130.     { 
131.         ipDataFile.seek(offset); 
132.          
133.         long result = 0; 
134.         if(nByte > 4 || nByte < 0) 
135.             throw new Exception("nBit should be 0-4"); 
136.          
137.         for(int i = 0; i < nByte; i++) 
138.         { 
139.             result |= ((long)ipDataFile.readByte() << 8 * i) & (0xFFL << 8 * i); 
140.         } 
141.          
142.         return result; 
143.     } 
144.      
145.     private String[] getInfo(long itemStartPos) throws Exception 
146.     { 
147.         //result[0]放国家，result[1]放地区 
148.         String[] result = new String[2]; 
149.          
150.         ipDataFile.seek(itemStartPos); 
151.         int mode = (int)ipDataFile.readByte(); 
152.         switch (mode) 
153.         { 
154.         case MODE_1: 
155.         { 
156.             long offset = itemStartPos + 1; 
157.             long redirPos = readLong(3, offset); 
158.             result = getInfo(redirPos); 
159.         } 
160.         break; 
161.         case MODE_2: 
162.         { 
163.             long offset = itemStartPos + 1; 
164.             long redirPos = readLong(3, offset); 
165.             result = getInfo(redirPos); 
166.             result[1] = getArea(offset + 3); 
167.         } 
168.         break; 
169.         default://MODE_3 
170.         { 
171.             long offset = itemStartPos; 
172.             int countryLen = getStrLength(offset); 
173.             result[0] = getString(offset, countryLen); 
174.              
175.             offset = itemStartPos + countryLen + 1; 
176.             result[1] = getArea(offset); 
177.         } 
178.         break; 
179.         } 
180.         return result; 
181.     } 
182.          
183.     private String getArea(long offset) throws Exception 
184.     { 
185.         ipDataFile.seek(offset); 
186.         int cityMode = (int)ipDataFile.readByte(); 
187.         if(cityMode ==  MODE_2 || cityMode ==  MODE_1) 
188.         { 
189.             offset = readLong(3, offset + 1); 
190.         } 
191.          
192.         int cityLen = getStrLength(offset);  
193.         return getString(offset, cityLen);   
194.     } 
195.      
196.     private int getStrLength(long pos) throws IOException 
197.     { 
198.         ipDataFile.seek(pos); 
199.         long strEnd = pos - 1; 
200.         while(ipDataFile.readByte() != (byte)0) 
201.         { 
202.             strEnd++; 
203.         } 
204.          
205.         return (int) (strEnd - pos + 1); 
206.     } 
207.      
208.     private String getString(long pos, int len) throws IOException 
209.     { 
210.         byte buf[] = new byte[len]; 
211.          
212.         ipDataFile.seek(pos); 
213.         ipDataFile.read(buf); 
214.         String s = new String(buf, "gbk"); 
215.         return s; 
216.     } 
217.  
218. } 

 本文转自 dogegg250 51CTO博客，原文链接：http://blog.51cto.com/jianshusoft/624327，如需转载请自行联系原作者