程序博客网 > 欧洲难民 知乎

JAVA解析纯真IP地址库

来源：互联网 发布：欧洲难民 知乎 编辑：程序博客网 时间：2024/04/29 13:11

 前几天看了下Ruby的IPParse，觉得很过瘾，上网查了下貌似很多IP数据库都要收费的，就下了个纯真QQIP地址库，发现还可以在线升级的，很适合咱做点小玩意。具体解析的纯真版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.   
  2. package com.showtime.util;   
  3.   
  4. import org.apache.log4j.Level;   
  5. import org.apache.log4j.Logger;   
  6.   
  7. /**  
  8.  *   
  9.  *   
  10.  * 日志工厂  
  11.  */  
  12. public class LogFactory {   
  13.     private static final Logger logger;   
  14.     static {   
  15.         logger = Logger.getLogger("stdout");   
  16.         logger.setLevel(Level.DEBUG);   
  17.     }   
  18.   
  19.     public static void log(String info, Level level, Throwable ex) {   
  20.         logger.log(level, info, ex);   
  21.     }   
  22.        
  23.     public static Level  getLogLevel(){   
  24.         return logger.getLevel();   
  25.     }   
  26.   
  27. }  



下面是测试类

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. }  


当输出：湖南省长沙市:网通


大功告成。
传了半天，项目只有18K，怎么传不上来呢，先发了帖子再说吧。

欧洲难民 知乎 欧洲难民 知乎
原创粉丝点击
热门IT博客
个人信用基础数据库个人信用基础数据库
java变量命名格式java变量命名格式
cd转mp3软件
九阴真经抢号软件
蜘蛛侠淘宝客网站源码
广州买西服知乎
网络机顶盒apk软件大全
生产软件
维吉尼亚密码c语言
mysql临时表创建
mac重装找不到硬盘
网络主播大秀在线视频
哪个电台软件好
java团队开发工具
c语言编译器在线
编程人员工资
印象笔记mac版
淘宝收藏店铺在哪里
软件测试专业介绍
游戏程序员工资待遇
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 回到乡村做隐士 山村田园隐士 南山隐士作品 乡村隐士系统 调查蓝色隐士 都市之超级隐士 隐士首富张牧 终南山女隐士怀孕 隐士是什么意思 终南山吧 终南山 王维 西安终南山 终南山图片 终南山在哪个省 终南山在哪里 终南山在哪 终南山隐居费用 隐密而伟大 女生隐密部分图片 青盲续集第二部之隐密 隐居娱乐圈 隐居 隐居吧 终南山隐居 隐居生活 隐居之地 隐居洱海 陪你去隐居 隐居集团 隐居者 隐居深山 天隐居 隐居城市 隐居文化 陶渊明 隐居 隐居不仕 隐居山 寻湖隐居 当代隐居 隐居的诗句 陶渊明隐居

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里