原文：http://blog.csdn.net/chwshuang/article/details/78027873?locationNum=10&fps=1

Java使用纯真IP库获取IP对应省份和城市

项目上接到一个需求，按照用户IP地址判断用户省份、城市，来展示不同的内容。在网上进行选型的时候，有几个选择

开源免费的IP库选型

  1. GeoIP2 GeoLite2开源免费的数据库

    MaxMind作为一家私营企业，总部设于美国马萨诸塞州的沃尔瑟姆。MaxMind公司成立于2002年，是领先业界的IP智能与在线欺诈检测工具供应商。有兴趣的可以访问官方网站了解。

    这个IP库的特点是免费，全球支持比较好，国外的IP应该比较全，国内的IP地址获取率不高，获取后的准确率也不高，公司网站上使用过一段时间，我统计过，国内地址获取率80%左右，而这80%里与淘宝的IP进行对比的准确率只有60%~80%，所以，整体的成功率只有65%以下，所以上线一段时间就没有用了。

  2. 淘宝IP库

    淘宝IP库只能通过Http方式查询IP，没有提供本地库的方式，遇到实时处理系统，肯定是不行，解决方案是建一个缓存和一个队列，如果缓存中没有的IP，就放到队列，然后用一个线程单独去队列中把要查询地址的IP通过Http的方式获取。

    淘宝IP库的特点是准确，官方宣称的省级准确率达到99.14%。缺点就是只提供线上的Rest API，而且线上的Rest API有请求限制，如果你写个程序一直请求，每个请求返回的间隔是30秒！所以不适合实时的场景用。

  3. 纯真IP库

    纯真IP库是国人开源的一个IP库，支持多语言的，它的格式是公开的，所以，你可以将它用在目前主流的开发语言的项目中。纯真IP库的获取率是99.99%，除非是本地内网IP，比如以192.168开头的一些IP会不认，而这个是没有影响的。而淘宝IP库比较有意思的是会返回本地IP这个地区描述。纯真库还有一个最大的好处，就是它在定期更新，且比较频繁，最新更新时间是几天前2017年9月15号。使用过程中库更新也比较方便，直接更新项目上的库文件，然后重启服务即可。当然，你也可以让程序手动或者自动定时触发更新。

    纯真IP库需要在Window的操作系统上安装程序，然后在安装目录（默认是 ?\cz88.net\ip\）找到qqwry.dat这个文件， 这个就是压缩后的IP本地库

. 
. 
.

纯真IP库使用

上面纯真IP介绍里已经说过怎么获取IP库文件，下面再说如何使用

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

总结

其实我也是从网络上找的解析纯真库代码[http://blog.csdn.net/rockstar541/article/details/7161505] , 当然，我的代码是在他的基础上进行优化的，主要的在高并发的情况下，会出现获取城市为空的情况，所以在以下几个地方有改进：

  • （1）ipCache初始化的时候使用并发Map
  1. ipCache = new HashMap<>();
  2. 替换为
  3. ipCache = new ConcurrentHashMap<>();
  • （2）获取IPLocation对象时进行同步处理，我尝试过将synchronized关键字加到更深或者更浅的方法上，在getIPLocation(String ip) 上加目前最安全，最高效
  1. public IPLocation getIPLocation(String ip) {
  2.     IPLocation location = new IPLocation();
  3.     location.setArea(this.getArea(ip));
  4.     location.setCountry(this.getCountry(ip));
  5.     return location;
  6. }
  7. 替换为
  8. public synchronized IPLocation getIPLocation(final String ip) {
  9.     IPLocation location = new IPLocation();
  10.     location.setArea(this.getArea(ip));
  11.     location.setCountry(this.getCountry(ip));
  12.     return location;
  13. }

Java使用纯真IP库获取IP对应省份和城市的更多相关文章

  1. python3.4学习笔记(二十三) Python调用淘宝IP库获取IP归属地返回省市运营商实例代码

    python3.4学习笔记(二十三) Python调用淘宝IP库获取IP归属地返回省市运营商实例代码 淘宝IP地址库 http://ip.taobao.com/目前提供的服务包括:1. 根据用户提供的 ...

  2. 使用新浪IP库获取IP详细地址

    使用新浪IP库获取IP详细地址 <?php class Tool{ /** * 获取IP的归属地( 新浪IP库 ) * * @param $ip String IP地址:112.65.102.1 ...

  3. 使用纯真IP库获取用户端地理位置信息

    引言 在一些电商类或者引流类的网站中经常会有获取用户地理位置信息的需求,下面我分享一个用纯真IP库获取用户地理位置信息的方案. 正文 第一步:本文的方案是基于纯真IP库的,所以首先要去下载最新的纯真I ...

  4. php利用淘宝IP库获取用户ip地理位置

    我们查ip的时候都是利用ip138查询的,不过那个有时候是不准确的,还不如自己引用淘宝的ip库来查询,这样准确度还高一些.不多说了,介绍一下淘宝IP地址库的使用. 淘宝IP地址库 淘宝公布了他们的IP ...

  5. php根据地理坐标获取国家、省份、城市，及周边数据类

    功能:当App获取到用户的地理坐标时,可以根据坐标知道用户当前在那个国家.省份.城市,及周边有什么数据. 原理:基于百度Geocoding API 实现,需要先注册百度开发者,然后申请百度AK(密钥) ...

  6. php依据地理坐标获取国家、省份、城市，及周边数据类

    功能:当App获取到用户的地理坐标时,能够依据坐标知道用户当前在那个国家.省份.城市.及周边有什么数据. 原理:基于百度Geocoding API 实现.须要先注冊百度开发人员.然后申请百度AK(密钥 ...

  7. Python之通过IP地址库获取IP地理信息

    利用第三方的IP地址库,各个公司可以根据自己的业务情况打造自己的IP地址采集分析系统.例如游戏公司可以采集玩家地区信息,进行有针对性的运营策略,还可能帮助分析玩家网络故障分布等等. #!/usr/bi ...

  8. PHP Swoole 基于纯真IP库根据IP匹配城市

    把纯真IP库读到内存,纯真IP库本来就是有序的,然后每次请求二分查找就行,44WIP查找十几次就搞定了 dispatch_mode最好写3,不然做服务的时候,会导致进程任务分配不均匀. max_req ...

  9. 根据IP地址获取IP的详细信息

    <?php header('Content-Type:text/html; charset=utf-8'); function ip_data() { $ip = GetIP(); $url = ...

随机推荐

  1. 关于hadoop: command not found的问题

    问题: 昨天在安装完hadoop伪分布式之后,执行hadoop下的子项目--文字计数功能时出现该错误,然后今天执行 hadoop fs -ls命令时系统给出同样的错误提醒,经过查找资料,初步认为是ha ...

  2. codechef T2 Chef and Sign Sequences

    CHEFSIGN: 大厨与符号序列题目描述 大厨昨天捡到了一个奇怪的字符串 s,这是一个仅包含‘<’.‘=’和‘>’三种比较符号的字符串. 记字符串长度为 N,大厨想要在字符串的开头.结尾 ...

  3. [bzoj1770][Usaco2009 Nov]lights 燈——Gauss消元法

    题意 给定一个无向图,初始状态所有点均为黑,如果更改一个点,那么它和与它相邻的点全部会被更改.一个点被更改当它的颜色与之前相反. 题解 第一道Gauss消元题.所谓gauss消元,就是使用初等行列式变 ...

  4. VC6.0显示行号的插件

    VC6.0显示行号的插件,很好很强大的显行号插件,使用VC编程的朋友再也不用烦恼VC6.0没有行号的编程环境了. VC显示行号插件使用说明:1. 如果你的VC安装在C盘,请拷贝文件VC6LineNum ...

  5. 《linux下进程的创建，执行，监控和终止》

    <linux下进程的创建,执行,监控和终止> http://blog.csdn.net/miss_acha/article/details/43671047 http://blog.csd ...

  6. 算法题之Climbing Stairs（leetcode 70）

    题目: You are climbing a stair case. It takes n steps to reach to the top. Each time you can either cl ...

  7. servlet(4) - servletAPI - 小易Java笔记

    Servlet规范核心类图 1.请求和响应对象 ==> HTTP协议包含请求和响应部分. ==> HttpServletRequest就代表着请求部分 ==> HttpServlet ...

  8. springboot整合jsp模板

    springboot整合jsp模板 在使用springboot框架里使用jsp的时候,页面模板使用jsp在pom.xnl中需要引入相关的依赖,否则在controller中无法返回到指定页面 〇.搭建s ...

  9. EasyUI的tree展开所有的节点或者根据特殊的条件控制展示指定的节点

    展示tree下的所有节点$(function(){ $('#t_funinfo_tree').tree({ checkbox: true, url:"<%=basePath %> ...

  10. 推荐下载App，如果本地安装则直接打开本地App（Android/IOS）

    推荐下载App,如果本地安装则直接打开本地App(Android/IOS) - 纵观现在每家移动网站,打开首页的时候,都有各种各样的形式来提示你下载自身的移动App(Android/IOS),这是做移 ...