Terry.Li-彬

虚其心，可解天下之问；专其心，可治天下之学；静其心，可悟天下之理；恒其心，可成天下之业。
  BlogJava :: 首页 :: 新随笔 :: 联系 :: 聚合  :: 管理 ::
  143 随笔 :: 344 文章 :: 130 评论 :: 0 Trackbacks
JAVA解析纯真IP地址库
具体解析的纯真版IP地址库请详见http://lumaqq.linuxsir.org/article/qqwry_format_detail.html，这里就不多叙述了。 
看下JAVA代码中怎么解析IP的吧。（代码参考至lumaQQ.谢谢开源作者luma） 


解析的主类 
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 == 0) return ipBegin;  
  407.         else if(r < 0) return -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 <= 0) return 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-17 22:28 礼物 阅读(5711) 评论(1)  编辑  收藏

评论

# re: JAVA解析纯真IP地址库 2014-04-27 12:42 苏秦
你这个有多线程并发问题  回复  更多评论
  


只有注册用户登录后才能发表评论。
网站导航: