Terry.Li-彬

虚其心,可解天下之问;专其心,可治天下之学;静其心,可悟天下之理;恒其心,可成天下之业。

  BlogJava :: 首页 :: 新随笔 :: 联系 :: 聚合  :: 管理 ::
  143 随笔 :: 344 文章 :: 130 评论 :: 0 Trackbacks
摘要
网络上的IP数据库以纯真版的最为流行,LumaQQ也采用了纯真版IP数据库做为IP查询功能的基础。不过关于其格式的文档却非常之少,后来终于在网上 找到了一份文档,得以了解其内幕,不过那份文档寥寥数语,也是颇为耐心才读明白。在这里我重写一份,以此做为LumaQQ开发者文档的一部分,我想还是必 要的。本文详细介绍了纯真IP数据库的格式,并且给出了一些Demo以供参考。

Luma, 清华大学
修改日期: 2005/01/14

Note: 在此感谢纯真IP数据库作者金狐和那唯一一份文档的作者。

修改历史:
2005-01-14 修改了原来一些表达不清和错误的地方


自从有了IP数据库这种东西,QQ外挂的显示IP功能也随之而生,本人见识颇窄,是否还有其他应用不得而知,不过,IP数据库确实是个不错的东西。 如今网络上最流行的IP数据库我想应该是纯真版的(说错了也不要扁我),迄今为止其IP记录条数已经接近30000,对于有些IP甚至能精确到楼层,不亦 快哉。2004年4、5月间,正逢LumaQQ破土动工,为了加上这个人人都喜欢,但是好像人人都不知道为什么喜欢的显IP功能,我也采用了纯真版IP数 据库,它的优点是记录多,查询速度快,它只用一个文件QQWry.dat就包含了所有记录,方便嵌入到其他程序中,也方便升级。

基本结构

QQWry.dat文件在结构上分为3块:文件头,记录区,索引区。一般我们要查找IP时,先在索引区查找记录偏移,然后再到记录区读出信息。由于 记录区的记录是不定长的,所以直接在记录区中搜索是不可能的。由于记录数比较多,如果我们遍历索引区也会是有点慢的,一般来说,我们可以用二分查找法搜索 索引区,其速度比遍历索引区快若干数量级。图1是QQWry.dat的文件结构图。



图1. QQWry.dat文件结构

要注意的是,QQWry.dat里面全部采用了little-endian字节序

一. 了解文件头

QQWry.dat的文件头只有8个字节,其结构非常简单,首四个字节是第一条索引的绝对偏移,后四个字节是最后一条索引的绝对偏移。

二. 了解记录区

每条IP记录都由国家和地区名组成,国家地区在这里并不是太确切,因为可能会查出来“清华大学计算机系”之类的,这里清华大学就成了国家名了,所以 这个国家地区名和IP数据库制作的时候有关系。所以记录的格式有点像QName,有一个全局部分和局部部分组成,我们这里还是沿用国家名和地区名的说法。

于是我们想象着一条记录的格式应该是: [IP地址][国家名][地区名],当然,这个没有什么问题,但是这只是最简单的情况。很显然,国家名和地区名可能会有很多的重复,如果每条记录都保存一 个完整的名称拷贝是非常不理想的,所以我们就需要重定向以节省空间。所以为了得到一个国家名或者地区名,我们就有了两个可能:第一就是直接的字符串表示的 国家名,第二就是一个4字节的结构,第一个字节表明了重定向的模式,后面3个字节是国家名或者地区名的实际偏移位置。对于国家名来说,情况还可能更复杂 些,因为这样的重定向最多可能有两次。

那么什么是重定向模式?根据上面所说,一条记录的格式是[IP地址][国家记录][地区记录],如果国家记录是重定向的话,那么地区记录是有可能没有的,于是就有了两种情况,我管他叫做模式1和模式2。我们对这些格式的情况举图说明:



图2. IP记录的最简单形式

图2表示了最简单的IP记录格式,我想没有什么可以解释的



图3. 重定向模式1

图3演示了重定向模式1的情况。我们看到在模式1的情况下,地区记录也跟着国家记录走了,在IP地址之后只剩下了国家记录的4字节,后面3个字节构成了一个指针,指向了实际的国家名,然后又跟着地址名。模式1的标识字节是0x01。



图4. 重定向模式2

图4演示了重定向模式2的情况。我们看到了在模式2的情况下(其标识字节是0x02),地区记录没有跟着国家记录走,因此在国家记录之后4个字节之 后还是有地区记录。我想你已经明白了模式1和模式2的区别,即:模式1的国家记录后面不会再有地区记录,模式2的国家记录后会有地区记录。下面我们来看一 下更复杂的情况。



图5. 混和情况1

图5演示了当国家记录为模式1的时候可能出现的更复杂情况,在这种情况下,重定向指向的位置仍然是个重定向,不过第二次重定向为模式2。大家不用担 心,没有模式3了,这个重定向也最多只有两次,并且如果发生了第二次重定向,则其一定为模式2,而且这种情况只会发生在国家记录上,对于地区记录,模式1 和模式2是一样的,地区记录也不会发生2次重定向。不过,这个图还可以更复杂,如图7:



图6. 混和情况2

图6是模式1下最复杂的混和情况,不过我想应该也很好理解,只不过地区记录也来重定向而已,有一点我要提醒你,如果重定向的地址是0,则表示未知的地区名。

所以我们总结如下:一条IP记录由[IP地址][国家记录][地区记录]组成,对于国家记录,可以有三种表示方式:字符串形式,重定向模式1和重定 向模式2。对于地区记录,可以有两种表示方式:字符串形式和重定向,另外有一条规则:重定向模式1的国家记录后不能跟地区记录。按照这个总结,在这些方式 中合理组合,就构成了IP记录的所有可能情况。

设计的理由

在我们继续去了解索引区的结构之前,我们先来了解一下为何记录区的结构要如此设计。我想你可能想到了答案:字符串重用。没错,在这种结构下,对于一 个国家名和地区名,我只需要保存其一次就可以了。我们举例说明,为了表示方便,我们用小写字母代表IP记录,C表示国家名,A表示地区名:

  1. 有两条记录a(C1, A1), b(C2, A2),如果C1 = C2, A1 = A2,那么我们就可以使用图3显示的结构来实现重用
  2. 有三条记录a(C1, A1), b(C2, A2), c(C3, A3),如果C1 = C2, A2 = A3,现在我们想存储记录b,那么我们可以用图6的结构来实现重用
  3. 有两条记录a(C1, A1), b(C2, A2),如果C1 = C2,现在我们想存储记录b,那么我们可以采用模式2表示C2,用字符串表示A2

你可以举出更多的情况,你也会发现在这种结构下,不同的字符串只需要存储一次。

了解索引区

在"了解文件头"部分,我们说明了文件头实际上是两个指针,分别指向了第一条索引和最后一条索引的绝对偏移。如图8所示:



图8. 文件头指向索引区图示

实在是很简单,不是吗?从文件头你就可以定位到索引区,然后你就可以开始搜索IP了!每条索引长度为7个字节,前4个字节是起始IP地址,后三个字 节就指向了IP记录。这里有些概念需要说明一下,什么是起始IP,那么有没有结束IP? 假设有这么一条记录:166.111.0.0 - 166.111.255.255,那么166.111.0.0就是起始IP,166.111.255.255就是结束IP,结束IP就是IP记录中的那头 4个字节,这下你应该就清楚了吧。于是乎,每条索引配合一条记录,构成了一个IP范围,如果你要查找166.111.138.138所在的位置,你就会发 现166.111.138.138落在了166.111.0.0 - 166.111.255.255 这个范围内,那么你就可以顺着这条索引去读取国家和地区名了。那么我们给出一个最详细的图解吧:



图9. 文件详细结构

现在一切都清楚了是不是?也许还有一点你不清楚,QQWry.dat的版本信息存在哪里呢? 答案是:最后一条IP记录实际上就是版本信息,最后一条记录显示出来就是这样:255.255.255.0 255.255.255.255 纯真网络 2004年6月25日IP数据。OK,到现在你应该全部清楚了。

Demo

下一步:我给出一个读取IP记录的程序片断,此片断摘录自LumaQQ源文件edu.tsinghua.lumaqq.IPSeeker.java,如果你有兴趣,可以下载源代码详细看看。

	/**
* 给定一个ip国家地区记录的偏移,返回一个IPLocation结构
* @param offset 国家记录的起始偏移
* @return IPLocation对象
*/
private IPLocation getIPLocation(long offset) {
try {
// 跳过4字节ip
ipFile.seek(offset + 4);
// 读取第一个字节判断是否标志字节
byte b = ipFile.readByte();
if(b == REDIRECT_MODE_1) {
// 读取国家偏移
long countryOffset = readLong3();
// 跳转至偏移处
ipFile.seek(countryOffset);
// 再检查一次标志字节,因为这个时候这个地方仍然可能是个重定向
b = ipFile.readByte();
if(b == REDIRECT_MODE_2) {
loc.country = readString(readLong3());
ipFile.seek(countryOffset + 4);
} else
loc.country = readString(countryOffset);
// 读取地区标志
loc.area = readArea(ipFile.getFilePointer());
} else if(b == REDIRECT_MODE_2) {
loc.country = readString(readLong3());
loc.area = readArea(offset + 8);
} else {
loc.country = readString(ipFile.getFilePointer() - 1);
loc.area = readArea(ipFile.getFilePointer());
}
return loc;
} catch (IOException e) {
return null;
}
}

/**
* 从offset偏移开始解析后面的字节,读出一个地区名
* @param offset 地区记录的起始偏移
* @return 地区名字符串
* @throws IOException 地区名字符串
*/
private String readArea(long offset) throws IOException {
ipFile.seek(offset);
byte b = ipFile.readByte();
if(b == REDIRECT_MODE_1 || b == REDIRECT_MODE_2) {
long areaOffset = readLong3(offset + 1);
if(areaOffset == 0)
return LumaQQ.getString("unknown.area");
else
return readString(areaOffset);
} else
return readString(offset);
}

/**
* 从offset位置读取3个字节为一个long,因为java为big-endian格式,所以没办法
* 用了这么一个函数来做转换
* @param offset 整数的起始偏移
* @return 读取的long值,返回-1表示读取文件失败
*/
private long readLong3(long offset) {
long ret = 0;
try {
ipFile.seek(offset);
ipFile.readFully(b3);
ret |= (b3[0] & 0xFF);
ret |= ((b3[1] << 8) & 0xFF00);
ret |= ((b3[2] << 16) & 0xFF0000);
return ret;
} catch (IOException e) {
return -1;
}
}

/**
* 从当前位置读取3个字节转换成long
* @return 读取的long值,返回-1表示读取文件失败
*/
private long readLong3() {
long ret = 0;
try {
ipFile.readFully(b3);
ret |= (b3[0] & 0xFF);
ret |= ((b3[1] << 8) & 0xFF00);
ret |= ((b3[2] << 16) & 0xFF0000);
return ret;
} catch (IOException e) {
return -1;
}
}

/**
* 从offset偏移处读取一个以0结束的字符串
* @param offset 字符串起始偏移
* @return 读取的字符串,出错返回空字符串
*/
private String readString(long offset) {
try {
ipFile.seek(offset);
int i;
for(i = 0, buf[i] = ipFile.readByte(); buf[i] != 0; buf[++i] = ipFile.readByte());
if(i != 0)
return Utils.getString(buf, 0, i, "GBK");
} catch (IOException e) {
log.error(e.getMessage());
}
return "";
}

代码并不复杂,getIPLocation是主要方法,它检查国家记录格式,并针对字符串形式,模式1,模式2采用不同的代码,readArea则相对简单,因为只有字符串和重定向两种情况需要处理。

总结

纯真IP数据库的结构使得查找IP简单迅速,不过你想要编辑它却是比较麻烦的,我想应该需要专门的工具来生成QQWry.dat文件,由于其文件格式的限制,你要直接添加IP记录就不容易了。不过,能查到IP已经很开心了,希望纯真记录越来越多~。




解析的主类

Java代码
  1. package  com.showtime.IPparse;  
  2.   
  3. import  java.io.File;  
  4. import  java.io.FileNotFoundException;  
  5. import  java.io.IOException;  
  6. import  java.io.RandomAccessFile;  
  7. import  java.nio.ByteOrder;  
  8. import  java.nio.MappedByteBuffer;  
  9. import  java.nio.channels.FileChannel;  
  10. import  java.util.ArrayList;  
  11. import  java.util.HashMap;  
  12. import  java.util.List;  
  13. import  java.util.Map;  
  14. import  com.showtime.util.LogFactory;  
  15. import  org.apache.log4j.Level;  
  16.   
  17. public   class  IPSeeker {  
  18.     //纯真IP数据库名  
  19.     private String IP_FILE="QQWry.Dat";  
  20.     //保存的文件夹  
  21.     private String INSTALL_DIR="f:/qqwry";  
  22.       
  23.       
  24.     // 一些固定常量,比如记录长度等等  
  25.     private static final int IP_RECORD_LENGTH = 7;  
  26.     private static final byte REDIRECT_MODE_1 = 0x01;  
  27.     private static final byte REDIRECT_MODE_2 = 0x02;  
  28.       
  29.     // 用来做为cache,查询一个ip时首先查看cache,以减少不必要的重复查找  
  30.     private Map<String, IPLocation> ipCache;  
  31.     // 随机文件访问类  
  32.     private RandomAccessFile ipFile;  
  33.     // 内存映射文件  
  34.     private MappedByteBuffer mbb;  
  35.     // 起始地区的开始和结束的绝对偏移  
  36.     private long ipBegin, ipEnd;  
  37.     // 为提高效率而采用的临时变量  
  38.     private IPLocation loc;  
  39.     private byte[] buf;  
  40.     private byte[] b4;  
  41.     private byte[] b3;  
  42.       
  43.     public IPSeeker(String fileName,String dir)  {  
  44.         this.INSTALL_DIR=dir;  
  45.         this.IP_FILE=fileName;  
  46.         ipCache = new HashMap<String, IPLocation>();  
  47.         loc = new IPLocation();  
  48.         buf = new byte[100];  
  49.         b4 = new byte[4];  
  50.         b3 = new byte[3];  
  51.         try {  
  52.             ipFile = new RandomAccessFile(IP_FILE, "r");  
  53.         } catch (FileNotFoundException e) {  
  54.             // 如果找不到这个文件,再尝试再当前目录下搜索,这次全部改用小写文件名  
  55.             //     因为有些系统可能区分大小写导致找不到ip地址信息文件  
  56.             String filename = new File(IP_FILE).getName().toLowerCase();  
  57.             File[] files = new File(INSTALL_DIR).listFiles();  
  58.             for(int i = 0; i < files.length; i++) {  
  59.                 if(files[i].isFile()) {  
  60.                     if(files[i].getName().toLowerCase().equals(filename)) {  
  61.                         try {  
  62.                             ipFile = new RandomAccessFile(files[i], "r");  
  63.                         } catch (FileNotFoundException e1) {  
  64.                             LogFactory.log("IP地址信息文件没有找到,IP显示功能将无法使用",Level.ERROR,e1);  
  65.                             ipFile = null;  
  66.                         }  
  67.                         break;  
  68.                     }  
  69.                 }  
  70.             }  
  71.         }   
  72.         // 如果打开文件成功,读取文件头信息  
  73.         if(ipFile != null) {  
  74.             try {  
  75.                 ipBegin = readLong4(0);  
  76.                 ipEnd = readLong4(4);  
  77.                 if(ipBegin == -1 || ipEnd == -1) {  
  78.                     ipFile.close();  
  79.                     ipFile = null;  
  80.                 }             
  81.             } catch (IOException e) {  
  82.                 LogFactory.log("IP地址信息文件格式有错误,IP显示功能将无法使用",Level.ERROR,e);  
  83.                 ipFile = null;  
  84.             }             
  85.         }  
  86.     }  
  87.       
  88.       
  89.     /** 
  90.      * 给定一个地点的不完全名字,得到一系列包含s子串的IP范围记录 
  91.      * @param s 地点子串 
  92.      * @return 包含IPEntry类型的List 
  93.      */   
  94.     public List getIPEntriesDebug(String s) {  
  95.         List<IPEntry> ret = new ArrayList<IPEntry>();  
  96.         long endOffset = ipEnd + 4;  
  97.         for(long offset = ipBegin + 4; offset <= endOffset; offset += IP_RECORD_LENGTH) {  
  98.             // 读取结束IP偏移  
  99.             long temp = readLong3(offset);  
  100.             // 如果temp不等于-1,读取IP的地点信息  
  101.             if(temp != -1) {  
  102.                 IPLocation ipLoc = getIPLocation(temp);  
  103.                 // 判断是否这个地点里面包含了s子串,如果包含了,添加这个记录到List中,如果没有,继续  
  104.                 if(ipLoc.getCountry().indexOf(s) != -1 || ipLoc.getArea().indexOf(s) != -1) {  
  105.                     IPEntry entry = new IPEntry();  
  106.                     entry.country = ipLoc.getCountry();  
  107.                     entry.area = ipLoc.getArea();  
  108.                     // 得到起始IP  
  109.                     readIP(offset - 4, b4);  
  110.                     entry.beginIp = Util.getIpStringFromBytes(b4);  
  111.                     // 得到结束IP  
  112.                     readIP(temp, b4);  
  113.                     entry.endIp = Util.getIpStringFromBytes(b4);  
  114.                     // 添加该记录  
  115.                     ret.add(entry);  
  116.                 }  
  117.             }  
  118.         }  
  119.         return ret;  
  120.     }  
  121.       
  122.     public IPLocation getIPLocation(String ip){  
  123.         IPLocation location=new IPLocation();  
  124.         location.setArea(this.getArea(ip));  
  125.         location.setCountry(this.getCountry(ip));  
  126.         return location;  
  127.     }  
  128.       
  129.     /** 
  130.      * 给定一个地点的不完全名字,得到一系列包含s子串的IP范围记录 
  131.      * @param s 地点子串 
  132.      * @return 包含IPEntry类型的List 
  133.      */   
  134.     public List<IPEntry> getIPEntries(String s) {  
  135.         List<IPEntry> ret = new ArrayList<IPEntry>();  
  136.         try {  
  137.             // 映射IP信息文件到内存中  
  138.             if(mbb == null) {  
  139.                 FileChannel fc = ipFile.getChannel();  
  140.                 mbb = fc.map(FileChannel.MapMode.READ_ONLY, 0, ipFile.length());  
  141.                 mbb.order(ByteOrder.LITTLE_ENDIAN);               
  142.             }  
  143.               
  144.             int endOffset = (int)ipEnd;  
  145.             for(int offset = (int)ipBegin + 4; offset <= endOffset; offset += IP_RECORD_LENGTH) {  
  146.                 int temp = readInt3(offset);  
  147.                 if(temp != -1) {  
  148.                     IPLocation ipLoc = getIPLocation(temp);  
  149.                     // 判断是否这个地点里面包含了s子串,如果包含了,添加这个记录到List中,如果没有,继续  
  150.                     if(ipLoc.getCountry().indexOf(s) != -1 || ipLoc.getArea().indexOf(s) != -1) {  
  151.                         IPEntry entry = new IPEntry();  
  152.                         entry.country = ipLoc.getCountry();  
  153.                         entry.area = ipLoc.getArea();  
  154.                         // 得到起始IP  
  155.                         readIP(offset - 4, b4);  
  156.                         entry.beginIp = Util.getIpStringFromBytes(b4);  
  157.                         // 得到结束IP  
  158.                         readIP(temp, b4);  
  159.                         entry.endIp = Util.getIpStringFromBytes(b4);  
  160.                         // 添加该记录  
  161.                         ret.add(entry);  
  162.                     }  
  163.                 }  
  164.             }             
  165.         } catch (IOException e) {  
  166.             LogFactory.log("",Level.ERROR,e);  
  167.         }  
  168.         return ret;  
  169.     }  
  170.   
  171.     /** 
  172.      * 从内存映射文件的offset位置开始的3个字节读取一个int 
  173.      * @param offset 
  174.      * @return 
  175.      */   
  176.     private int readInt3(int offset) {  
  177.         mbb.position(offset);  
  178.         return mbb.getInt() & 0x00FFFFFF;  
  179.     }  
  180.   
  181.     /** 
  182.      * 从内存映射文件的当前位置开始的3个字节读取一个int 
  183.      * @return 
  184.      */   
  185.     private int readInt3() {  
  186.         return mbb.getInt() & 0x00FFFFFF;  
  187.     }  
  188.       
  189.     /** 
  190.      * 根据IP得到国家名 
  191.      * @param ip ip的字节数组形式 
  192.      * @return 国家名字符串 
  193.      */   
  194.     public String getCountry(byte[] ip) {  
  195.         // 检查ip地址文件是否正常  
  196.         if(ipFile == null)   
  197.             return Message.bad_ip_file;  
  198.         // 保存ip,转换ip字节数组为字符串形式  
  199.         String ipStr = Util.getIpStringFromBytes(ip);  
  200.         // 先检查cache中是否已经包含有这个ip的结果,没有再搜索文件  
  201.         if(ipCache.containsKey(ipStr)) {  
  202.             IPLocation ipLoc = ipCache.get(ipStr);  
  203.             return ipLoc.getCountry();  
  204.         } else {  
  205.             IPLocation ipLoc = getIPLocation(ip);  
  206.             ipCache.put(ipStr, ipLoc.getCopy());  
  207.             return ipLoc.getCountry();  
  208.         }  
  209.     }  
  210.       
  211.     /** 
  212.      * 根据IP得到国家名 
  213.      * @param ip IP的字符串形式 
  214.      * @return 国家名字符串 
  215.      */   
  216.     public String getCountry(String ip) {  
  217.         return getCountry(Util.getIpByteArrayFromString(ip));  
  218.     }  
  219.       
  220.     /** 
  221.      * 根据IP得到地区名 
  222.      * @param ip ip的字节数组形式 
  223.      * @return 地区名字符串 
  224.      */   
  225.     public String getArea(byte[] ip) {  
  226.         // 检查ip地址文件是否正常  
  227.         if(ipFile == null)   
  228.             return Message.bad_ip_file;  
  229.         // 保存ip,转换ip字节数组为字符串形式  
  230.         String ipStr = Util.getIpStringFromBytes(ip);  
  231.         // 先检查cache中是否已经包含有这个ip的结果,没有再搜索文件  
  232.         if(ipCache.containsKey(ipStr)) {  
  233.             IPLocation ipLoc = ipCache.get(ipStr);  
  234.             return ipLoc.getArea();  
  235.         } else {  
  236.             IPLocation ipLoc = getIPLocation(ip);  
  237.             ipCache.put(ipStr, ipLoc.getCopy());  
  238.             return ipLoc.getArea();  
  239.         }  
  240.     }  
  241.       
  242.     /** 
  243.      * 根据IP得到地区名 
  244.      * @param ip IP的字符串形式 
  245.      * @return 地区名字符串 
  246.      */   
  247.     public String getArea(String ip) {  
  248.         return getArea(Util.getIpByteArrayFromString(ip));  
  249.     }  
  250.       
  251.     /** 
  252.      * 根据ip搜索ip信息文件,得到IPLocation结构,所搜索的ip参数从类成员ip中得到 
  253.      * @param ip 要查询的IP 
  254.      * @return IPLocation结构 
  255.      */   
  256.     private IPLocation getIPLocation(byte[] ip) {  
  257.         IPLocation info = null;  
  258.         long offset = locateIP(ip);  
  259.         if(offset != -1)  
  260.             info = getIPLocation(offset);  
  261.         if(info == null) {  
  262.             info = new IPLocation();  
  263.             info.setCountry (  Message.unknown_country);  
  264.             info.setArea(Message.unknown_area);  
  265.         }  
  266.         return info;  
  267.     }     
  268.   
  269.     /** 
  270.      * 从offset位置读取4个字节为一个long,因为java为big-endian格式,所以没办法 
  271.      * 用了这么一个函数来做转换 
  272.      * @param offset 
  273.      * @return 读取的long值,返回-1表示读取文件失败 
  274.      */   
  275.     private long readLong4(long offset) {  
  276.         long ret = 0;  
  277.         try {  
  278.             ipFile.seek(offset);  
  279.             ret |= (ipFile.readByte() & 0xFF);  
  280.             ret |= ((ipFile.readByte() << 8) & 0xFF00);  
  281.             ret |= ((ipFile.readByte() << 16) & 0xFF0000);  
  282.             ret |= ((ipFile.readByte() << 24) & 0xFF000000);  
  283.             return ret;  
  284.         } catch (IOException e) {  
  285.             return -1;  
  286.         }  
  287.     }  
  288.   
  289.     /** 
  290.      * 从offset位置读取3个字节为一个long,因为java为big-endian格式,所以没办法 
  291.      * 用了这么一个函数来做转换 
  292.      * @param offset 整数的起始偏移 
  293.      * @return 读取的long值,返回-1表示读取文件失败 
  294.      */   
  295.     private long readLong3(long offset) {  
  296.         long ret = 0;  
  297.         try {  
  298.             ipFile.seek(offset);  
  299.             ipFile.readFully(b3);  
  300.             ret |= (b3[0] & 0xFF);  
  301.             ret |= ((b3[1] << 8) & 0xFF00);  
  302.             ret |= ((b3[2] << 16) & 0xFF0000);  
  303.             return ret;  
  304.         } catch (IOException e) {  
  305.             return -1;  
  306.         }  
  307.     }     
  308.       
  309.     /** 
  310.      * 从当前位置读取3个字节转换成long 
  311.      * @return 读取的long值,返回-1表示读取文件失败 
  312.      */   
  313.     private long readLong3() {  
  314.         long ret = 0;  
  315.         try {  
  316.             ipFile.readFully(b3);  
  317.             ret |= (b3[0] & 0xFF);  
  318.             ret |= ((b3[1] << 8) & 0xFF00);  
  319.             ret |= ((b3[2] << 16) & 0xFF0000);  
  320.             return ret;  
  321.         } catch (IOException e) {  
  322.             return -1;  
  323.         }  
  324.     }  
  325.     
  326.     /** 
  327.      * 从offset位置读取四个字节的ip地址放入ip数组中,读取后的ip为big-endian格式,但是 
  328.      * 文件中是little-endian形式,将会进行转换 
  329.      * @param offset 
  330.      * @param ip 
  331.      */   
  332.     private void readIP(long offset, byte[] ip) {  
  333.         try {  
  334.             ipFile.seek(offset);  
  335.             ipFile.readFully(ip);  
  336.             byte temp = ip[0];  
  337.             ip[0] = ip[3];  
  338.             ip[3] = temp;  
  339.             temp = ip[1];  
  340.             ip[1] = ip[2];  
  341.             ip[2] = temp;  
  342.         } catch (IOException e) {  
  343.             LogFactory.log("",Level.ERROR,e);  
  344.         }  
  345.     }  
  346.       
  347.     /** 
  348.      * 从offset位置读取四个字节的ip地址放入ip数组中,读取后的ip为big-endian格式,但是 
  349.      * 文件中是little-endian形式,将会进行转换 
  350.      * @param offset 
  351.      * @param ip 
  352.      */   
  353.     private void readIP(int offset, byte[] ip) {  
  354.         mbb.position(offset);  
  355.         mbb.get(ip);  
  356.         byte temp = ip[0];  
  357.         ip[0] = ip[3];  
  358.         ip[3] = temp;  
  359.         temp = ip[1];  
  360.         ip[1] = ip[2];  
  361.         ip[2] = temp;  
  362.     }  
  363.       
  364.     /** 
  365.      * 把类成员ip和beginIp比较,注意这个beginIp是big-endian的 
  366.      * @param ip 要查询的IP 
  367.      * @param beginIp 和被查询IP相比较的IP 
  368.      * @return 相等返回0,ip大于beginIp则返回1,小于返回-1。 
  369.      */   
  370.     private int compareIP(byte[] ip, byte[] beginIp) {  
  371.         for(int i = 0; i < 4; i++) {  
  372.             int r = compareByte(ip[i], beginIp[i]);  
  373.             if(r != 0)  
  374.                 return r;  
  375.         }  
  376.         return 0;  
  377.     }  
  378.       
  379.     /** 
  380.      * 把两个byte当作无符号数进行比较 
  381.      * @param b1 
  382.      * @param b2 
  383.      * @return 若b1大于b2则返回1,相等返回0,小于返回-1 
  384.      */   
  385.     private int compareByte(byte b1, byte b2) {  
  386.         if((b1 & 0xFF) > (b2 & 0xFF)) // 比较是否大于  
  387.             return 1;  
  388.         else if((b1 ^ b2) == 0)// 判断是否相等  
  389.             return 0;  
  390.         else   
  391.             return -1;  
  392.     }  
  393.       
  394.     /** 
  395.      * 这个方法将根据ip的内容,定位到包含这个ip国家地区的记录处,返回一个绝对偏移 
  396.      * 方法使用二分法查找。 
  397.      * @param ip 要查询的IP 
  398.      * @return 如果找到了,返回结束IP的偏移,如果没有找到,返回-1 
  399.      */   
  400.     private long locateIP(byte[] ip) {  
  401.         long m = 0;  
  402.         int r;  
  403.         // 比较第一个ip项  
  404.         readIP(ipBegin, b4);  
  405.         r = compareIP(ip, b4);  
  406.         if(r == 0return ipBegin;  
  407.         else if(r < 0return -1;  
  408.         // 开始二分搜索  
  409.         for(long i = ipBegin, j = ipEnd; i < j; ) {  
  410.             m = getMiddleOffset(i, j);  
  411.             readIP(m, b4);  
  412.             r = compareIP(ip, b4);  
  413.             // log.debug(Utils.getIpStringFromBytes(b));  
  414.             if(r > 0)  
  415.                 i = m;  
  416.             else if(r < 0) {  
  417.                 if(m == j) {  
  418.                     j -= IP_RECORD_LENGTH;  
  419.                     m = j;  
  420.                 } else   
  421.                     j = m;  
  422.             } else  
  423.                 return readLong3(m + 4);  
  424.         }  
  425.         // 如果循环结束了,那么i和j必定是相等的,这个记录为最可能的记录,但是并非  
  426.         //     肯定就是,还要检查一下,如果是,就返回结束地址区的绝对偏移  
  427.         m = readLong3(m + 4);  
  428.         readIP(m, b4);  
  429.         r = compareIP(ip, b4);  
  430.         if(r <= 0return m;  
  431.         else return -1;  
  432.     }  
  433.       
  434.     /** 
  435.      * 得到begin偏移和end偏移中间位置记录的偏移 
  436.      * @param begin 
  437.      * @param end 
  438.      * @return 
  439.      */   
  440.     private long getMiddleOffset(long begin, long end) {  
  441.         long records = (end - begin) / IP_RECORD_LENGTH;  
  442.         records >>= 1;  
  443.         if(records == 0) records = 1;  
  444.         return begin + records * IP_RECORD_LENGTH;  
  445.     }  
  446.       
  447.     /** 
  448.      * 给定一个ip国家地区记录的偏移,返回一个IPLocation结构 
  449.      * @param offset 国家记录的起始偏移 
  450.      * @return IPLocation对象 
  451.      */   
  452.     private IPLocation getIPLocation(long offset) {  
  453.         try {  
  454.             // 跳过4字节ip  
  455.             ipFile.seek(offset + 4);  
  456.             // 读取第一个字节判断是否标志字节  
  457.             byte b = ipFile.readByte();  
  458.             if(b == REDIRECT_MODE_1) {  
  459.                 // 读取国家偏移  
  460.                 long countryOffset = readLong3();  
  461.                 // 跳转至偏移处  
  462.                 ipFile.seek(countryOffset);  
  463.                 // 再检查一次标志字节,因为这个时候这个地方仍然可能是个重定向  
  464.                 b = ipFile.readByte();  
  465.                 if(b == REDIRECT_MODE_2) {  
  466.                     loc.setCountry (  readString(readLong3()));  
  467.                     ipFile.seek(countryOffset + 4);  
  468.                 } else  
  469.                     loc.setCountry ( readString(countryOffset));  
  470.                 // 读取地区标志  
  471.                 loc.setArea( readArea(ipFile.getFilePointer()));  
  472.             } else if(b == REDIRECT_MODE_2) {  
  473.                 loc.setCountry ( readString(readLong3()));  
  474.                 loc.setArea( readArea(offset + 8));  
  475.             } else {  
  476.                 loc.setCountry (  readString(ipFile.getFilePointer() - 1));  
  477.                 loc.setArea( readArea(ipFile.getFilePointer()));  
  478.             }  
  479.             return loc;  
  480.         } catch (IOException e) {  
  481.             return null;  
  482.         }  
  483.     }     
  484.       
  485.     /** 
  486.      * 给定一个ip国家地区记录的偏移,返回一个IPLocation结构,此方法应用与内存映射文件方式 
  487.      * @param offset 国家记录的起始偏移 
  488.      * @return IPLocation对象 
  489.      */   
  490.     private IPLocation getIPLocation(int offset) {  
  491.         // 跳过4字节ip  
  492.         mbb.position(offset + 4);  
  493.         // 读取第一个字节判断是否标志字节  
  494.         byte b = mbb.get();  
  495.         if(b == REDIRECT_MODE_1) {  
  496.             // 读取国家偏移  
  497.             int countryOffset = readInt3();  
  498.             // 跳转至偏移处  
  499.             mbb.position(countryOffset);  
  500.             // 再检查一次标志字节,因为这个时候这个地方仍然可能是个重定向  
  501.             b = mbb.get();  
  502.             if(b == REDIRECT_MODE_2) {  
  503.                 loc.setCountry (  readString(readInt3()));  
  504.                 mbb.position(countryOffset + 4);  
  505.             } else  
  506.                 loc.setCountry (  readString(countryOffset));  
  507.             // 读取地区标志  
  508.             loc.setArea(readArea(mbb.position()));  
  509.         } else if(b == REDIRECT_MODE_2) {  
  510.             loc.setCountry ( readString(readInt3()));  
  511.             loc.setArea(readArea(offset + 8));  
  512.         } else {  
  513.             loc.setCountry (  readString(mbb.position() - 1));  
  514.             loc.setArea(readArea(mbb.position()));  
  515.         }  
  516.         return loc;  
  517.     }  
  518.       
  519.     /** 
  520.      * 从offset偏移开始解析后面的字节,读出一个地区名 
  521.      * @param offset 地区记录的起始偏移 
  522.      * @return 地区名字符串 
  523.      * @throws IOException 
  524.      */   
  525.     private String readArea(long offset) throws IOException {  
  526.         ipFile.seek(offset);  
  527.         byte b = ipFile.readByte();  
  528.         if(b == REDIRECT_MODE_1 || b == REDIRECT_MODE_2) {  
  529.             long areaOffset = readLong3(offset + 1);  
  530.             if(areaOffset == 0)  
  531.                 return Message.unknown_area;  
  532.             else  
  533.                 return readString(areaOffset);  
  534.         } else  
  535.             return readString(offset);  
  536.     }  
  537.       
  538.     /** 
  539.      * @param offset 地区记录的起始偏移 
  540.      * @return 地区名字符串 
  541.      */   
  542.     private String readArea(int offset) {  
  543.         mbb.position(offset);  
  544.         byte b = mbb.get();  
  545.         if(b == REDIRECT_MODE_1 || b == REDIRECT_MODE_2) {  
  546.             int areaOffset = readInt3();  
  547.             if(areaOffset == 0)  
  548.                 return Message.unknown_area;  
  549.             else  
  550.                 return readString(areaOffset);  
  551.         } else  
  552.             return readString(offset);  
  553.     }  
  554.       
  555.     /** 
  556.      * 从offset偏移处读取一个以0结束的字符串 
  557.      * @param offset 字符串起始偏移 
  558.      * @return 读取的字符串,出错返回空字符串 
  559.      */   
  560.     private String readString(long offset) {  
  561.         try {  
  562.             ipFile.seek(offset);  
  563.             int i;  
  564.             for(i = 0, buf[i] = ipFile.readByte(); buf[i] != 0; buf[++i] = ipFile.readByte());  
  565.             if(i != 0)   
  566.                 return Util.getString(buf, 0, i, "GBK");  
  567.         } catch (IOException e) {             
  568.             LogFactory.log("",Level.ERROR,e);  
  569.         }  
  570.         return "";  
  571.     }  
  572.       
  573.     /** 
  574.      * 从内存映射文件的offset位置得到一个0结尾字符串 
  575.      * @param offset 字符串起始偏移 
  576.      * @return 读取的字符串,出错返回空字符串 
  577.      */   
  578.     private String readString(int offset) {  
  579.         try {  
  580.             mbb.position(offset);  
  581.             int i;  
  582.             for(i = 0, buf[i] = mbb.get(); buf[i] != 0; buf[++i] = mbb.get());  
  583.             if(i != 0)   
  584.                 return Util.getString(buf, 0, i, "GBK");         
  585.         } catch (IllegalArgumentException e) {  
  586.             LogFactory.log("",Level.ERROR,e);  
  587.         }  
  588.         return "";     
  589.     }  
  590. }  


在实际项目用我使用spring注入IP地址库文件的名字和所在目录,并能保证IPSeeker的单一实例。


下面是个工具类,把string和btye数组之间互相转换的类。
Java代码
  1. package com.showtime.IPparse;  
  2.   
  3.   
  4. import java.io.UnsupportedEncodingException;  
  5. import java.util.StringTokenizer;  
  6.   
  7. import org.apache.log4j.Level;  
  8.   
  9. import  com.showtime.util.LogFactory;  
  10.   
  11.   
  12.   
  13. /** 
  14.  * 工具类,提供一些方便的方法 
  15.  */  
  16. public class Util {  
  17.       
  18.     private static StringBuilder sb = new StringBuilder();  
  19.     /** 
  20.      * 从ip的字符串形式得到字节数组形式 
  21.      * @param ip 字符串形式的ip 
  22.      * @return 字节数组形式的ip 
  23.      */  
  24.     public static byte[] getIpByteArrayFromString(String ip) {  
  25.         byte[] ret = new byte[4];  
  26.         StringTokenizer st = new StringTokenizer(ip, ".");  
  27.         try {  
  28.             ret[0] = (byte)(Integer.parseInt(st.nextToken()) & 0xFF);  
  29.             ret[1] = (byte)(Integer.parseInt(st.nextToken()) & 0xFF);  
  30.             ret[2] = (byte)(Integer.parseInt(st.nextToken()) & 0xFF);  
  31.             ret[3] = (byte)(Integer.parseInt(st.nextToken()) & 0xFF);  
  32.         } catch (Exception e) {  
  33.           LogFactory.log("从ip的字符串形式得到字节数组形式报错", Level.ERROR, e);  
  34.         }  
  35.         return ret;  
  36.     }  
  37.     /** 
  38.      * @param ip ip的字节数组形式 
  39.      * @return 字符串形式的ip 
  40.      */  
  41.     public static String getIpStringFromBytes(byte[] ip) {  
  42.         sb.delete(0, sb.length());  
  43.         sb.append(ip[0] & 0xFF);  
  44.         sb.append('.');       
  45.         sb.append(ip[1] & 0xFF);  
  46.         sb.append('.');       
  47.         sb.append(ip[2] & 0xFF);  
  48.         sb.append('.');       
  49.         sb.append(ip[3] & 0xFF);  
  50.         return sb.toString();  
  51.     }  
  52.       
  53.     /** 
  54.      * 根据某种编码方式将字节数组转换成字符串 
  55.      * @param b 字节数组 
  56.      * @param offset 要转换的起始位置 
  57.      * @param len 要转换的长度 
  58.      * @param encoding 编码方式 
  59.      * @return 如果encoding不支持,返回一个缺省编码的字符串 
  60.      */  
  61.     public static String getString(byte[] b, int offset, int len, String encoding) {  
  62.         try {  
  63.             return new String(b, offset, len, encoding);  
  64.         } catch (UnsupportedEncodingException e) {  
  65.             return new String(b, offset, len);  
  66.         }  
  67.     }  
  68. }  



下面是个常量值的类,用接口形式来定义省事不少。
Java代码
  1. package com.showtime.IPparse;  
  2.   
  3. public interface Message {  
  4.     String bad_ip_file="IP地址库文件错误";  
  5.     String unknown_country="未知国家";  
  6.     String unknown_area="未知地区";  
  7. }  



一个封装国家和地区的实体类
Java代码
  1. package com.showtime.IPparse;  
  2.   
  3.   
  4. /**  
  5.  *  
  6.  * @category 用来封装ip相关信息,目前只有两个字段,ip所在的国家和地区 
  7.  */  
  8.   
  9. public class IPLocation {  
  10.     private String country;  
  11.     private String area;  
  12.       
  13.     public IPLocation() {  
  14.         country = area = "";  
  15.     }  
  16.       
  17.     public IPLocation getCopy() {  
  18.         IPLocation ret = new IPLocation();  
  19.         ret.country = country;  
  20.         ret.area = area;  
  21.         return ret;  
  22.     }  
  23.   
  24.     public String getCountry() {  
  25.         return country;  
  26.     }  
  27.   
  28.     public void setCountry(String country) {  
  29.         this.country = country;  
  30.     }  
  31.   
  32.     public String getArea() {  
  33.         return area;  
  34.     }  
  35.   
  36.     public void setArea(String area) {  
  37.                 //如果为局域网,纯真IP地址库的地区会显示CZ88.NET,这里把它去掉  
  38.         if(area.trim().equals("CZ88.NET")){  
  39.             this.area="本机或本网络";  
  40.         }else{  
  41.             this.area = area;  
  42.         }  
  43.     }  
  44. }  



一下是一个范围记录的类
Java代码
  1. package com.showtime.IPparse;  
  2. /** 
  3.  * <pre> 
  4.  * 一条IP范围记录,不仅包括国家和区域,也包括起始IP和结束IP 
  5.  * </pre> 
  6.  */  
  7. public class IPEntry {  
  8.     public String beginIp;  
  9.     public String endIp;  
  10.     public String country;  
  11.     public String area;  
  12.       
  13.     /** 
  14.      * 构造函数 
  15.      */  
  16.     public IPEntry() {  
  17.         beginIp = endIp = country = area = "";  
  18.     }  
  19. }  


日志记录类
Java代码
  1. package com.showtime.util;  
  2.   
  3. import org.apache.log4j.Level;  
  4. import org.apache.log4j.Logger;  
  5.   
  6. /** 
  7.  *  
  8.  *  
  9.  * 日志工厂 
  10.  */  
  11. public class LogFactory {  
  12.     private static final Logger logger;  
  13.     static {  
  14.         logger = Logger.getLogger("stdout");  
  15.         logger.setLevel(Level.DEBUG);  
  16.     }  
  17.   
  18.     public static void log(String info, Level level, Throwable ex) {  
  19.         logger.log(level, info, ex);  
  20.     }  
  21.       
  22.     public static Level  getLogLevel(){  
  23.         return logger.getLevel();  
  24.     }  
  25.   
  26. }  


下面是测试类
Java代码
  1. package com.showtime.IPparse;  
  2.   
  3. import junit.framework.TestCase;  
  4.   
  5. public class IPtest extends TestCase {  
  6.       
  7.     public void testIp(){  
  8.                 //指定纯真数据库的文件名,所在文件夹  
  9.         IPSeeker ip=new IPSeeker("QQWry.Dat","f:/qqwry");  
  10.          //测试IP 58.20.43.13  
  11. System.out.println(ip.getIPLocation("58.20.43.13").getCountry()+":"+ip.getIPLocation("58.20.43.13").getArea());  
  12.     }  
  13. }  

当输出:湖南省长沙市:网通
posted on 2010-11-20 15:15 礼物 阅读(2532) 评论(0)  编辑  收藏 所属分类: java