Java根据IP地址获得归属地位置(分别使用淘宝IP地址库和qqwry.dat数据库)

在做登录日志的时候, 我不仅想显示IP,还想显示IP对应的归属地(省份或者城市)。

这里提供两种解决方案,调用淘宝IP地址库和使用 qqwry.dat 数据库。

前者只需要根据 http://ip.taobao.com/service/getIpInfo.php?ip=ip地址 返回 JSON 字符串,然后进行处理就行;

后者需要下载 qqwry.dat 文件,然后创建工具类来获取。

至于速度,不难猜出,本地的要快,即 qqwry.dat 比 淘宝 IP 地址库要快很多。

在一次测试的时候,qqwry.dat 方式只要 2 ms,淘宝 IP 地址库需要125 ms。

 

代码如下

一、根据 qqwry.dat 获取地理位置

1、下载 qqwry.dat 

百度自行下载,或者点此去CSDN下载

保存到本地某个路径下

 

2、application.properties

  1. qqwry.dat.path=/Users/liuyanzhao/Documents/MyUtil/qqwry.dat

为了方便维护,最后不要把文件路径写死在类里,我们自定义一个属性 qqwry.dat.path ,值为 qqwry.dat 物理路径(绝对路径),待会儿我们在 service 里使用 @Value("${qqwry.dat.path}") 就能获取

 

3、IPSeekerUtil.java 工具类

  1. package com.liuyanzhao.forum.util;
  2. import org.slf4j.Logger;
  3. import org.slf4j.LoggerFactory;
  4. import java.io.File;
  5. import java.io.IOException;
  6. import java.io.RandomAccessFile;
  7. import java.io.UnsupportedEncodingException;
  8. import java.nio.ByteOrder;
  9. import java.nio.MappedByteBuffer;
  10. import java.nio.channels.FileChannel;
  11. import java.util.ArrayList;
  12. import java.util.HashMap;
  13. import java.util.List;
  14. /**
  15.  * qqwry.dat获取归属地工具类
  16.  * @author 言曌
  17.  * @date 2018/4/9 下午8:39
  18.  */
  19. public class IPSeekerUtil {
  20.     private final Logger logger = LoggerFactory.getLogger(this.getClass());
  21.     private static final int IP_RECORD_LENGTH = 7;
  22.     private static final byte AREA_FOLLOWED = 0x01;
  23.     private static final byte NO_AREA = 0x2;
  24.     private MappedByteBuffer buffer; // 内存映射文件,提高IO 读取效率
  25.     private HashMap<String, IPLocation> cache = new HashMap<String, IPLocation>(); // 用来做为cache,查询一个ip时首先查看cache,以减少不必要的重复查找
  26.     private int ipBegin;
  27.     private int ipEnd;
  28.     @SuppressWarnings("resource")
  29.     public IPSeekerUtil(File file) throws Exception {
  30.         buffer = new RandomAccessFile(file, "r").getChannel().map(
  31.                 FileChannel.MapMode.READ_ONLY, 0, file.length());
  32.         if (buffer.order().toString().equals(ByteOrder.BIG_ENDIAN.toString())) {
  33.             buffer.order(ByteOrder.LITTLE_ENDIAN);
  34.         }
  35.         ipBegin = readInt(0);
  36.         ipEnd = readInt(4);
  37.         if (ipBegin == -1 || ipEnd == -1) {
  38.             throw new IOException("IP地址信息文件格式有错误,IP显示功能将无法使用");
  39.         }
  40.         logger.debug("使用IP地址库:" + file.getAbsolutePath());
  41.     }
  42.     /**
  43.      * 给定一个ip 得到一个 ip地址信息
  44.      *
  45.      * @param ip
  46.      * @return
  47.      */
  48.     public String getAddress(String ip) {
  49.         return getCountry(ip) + " " + getArea(ip);
  50.     }
  51.     /**
  52.      * 根据IP得到国家名
  53.      *
  54.      * @param ip
  55.      *            IP的字符串形式
  56.      * @return 国家名字符串
  57.      */
  58.     public String getCountry(String ip) {
  59.         IPLocation cache = getIpLocation(ip);
  60.         return cache.getCountry();
  61.     }
  62.     /**
  63.      * 根据IP得到地区名
  64.      *
  65.      * @param ip
  66.      *            IP的字符串形式
  67.      * @return 地区名字符串
  68.      */
  69.     public String getArea(String ip) {
  70.         IPLocation cache = getIpLocation(ip);
  71.         return cache.getArea();
  72.     }
  73.     /**
  74.      * 获得一个IP地址信息
  75.      *
  76.      * @param ip
  77.      * @return
  78.      */
  79.     public IPLocation getIpLocation(String ip) {
  80.         IPLocation ipLocation = null;
  81.         try {
  82.             if (cache.get(ip) != null) {
  83.                 return cache.get(ip);
  84.             }
  85.             ipLocation = getIPLocation(getIpByteArrayFromString(ip));
  86.             if (ipLocation != null) {
  87.                 cache.put(ip, ipLocation);
  88.             }
  89.         } catch (Exception e) {
  90.             logger.error(String.valueOf(e));
  91.         }
  92.         if (ipLocation == null) {
  93.             ipLocation = new IPLocation();
  94.             ipLocation.setCountry("未知国家");
  95.             ipLocation.setArea("未知地区");
  96.         }
  97.         return ipLocation;
  98.     }
  99.     /**
  100.      * 给定一个地点的不完全名字,得到一系列包含s子串的IP范围记录
  101.      *
  102.      * @param s
  103.      *            地点子串
  104.      * @return 包含IPEntry类型的List
  105.      */
  106.     public List<IPEntry> getIPEntries(String s) {
  107.         List<IPEntry> ret = new ArrayList<IPEntry>();
  108.         byte[] b4 = new byte[4];
  109.         int endOffset = ipEnd + 4;
  110.         for (int offset = ipBegin + 4; offset <= endOffset; offset += IP_RECORD_LENGTH) {
  111.             // 读取结束IP偏移
  112.             int temp = readInt3(offset);
  113.             // 如果temp不等于-1,读取IP的地点信息
  114.             if (temp != -1) {
  115.                 IPLocation loc = getIPLocation(temp);
  116.                 // 判断是否这个地点里面包含了s子串,如果包含了,添加这个记录到List中,如果没有,继续
  117.                 if (loc.country.indexOf(s) != -1 || loc.area.indexOf(s) != -1) {
  118.                     IPEntry entry = new IPEntry();
  119.                     entry.country = loc.country;
  120.                     entry.area = loc.area;
  121.                     // 得到起始IP
  122.                     readIP(offset - 4, b4);
  123.                     entry.beginIp = getIpStringFromBytes(b4);
  124.                     // 得到结束IP
  125.                     readIP(temp, b4);
  126.                     entry.endIp = getIpStringFromBytes(b4);
  127.                     // 添加该记录
  128.                     ret.add(entry);
  129.                 }
  130.             }
  131.         }
  132.         return ret;
  133.     }
  134.     /**
  135.      * 根据ip搜索ip信息文件,得到IPLocation结构,所搜索的ip参数从类成员ip中得到
  136.      *
  137.      * @param ip
  138.      *            要查询的IP
  139.      * @return IPLocation结构
  140.      */
  141.     private IPLocation getIPLocation(byte[] ip) {
  142.         IPLocation info = null;
  143.         int offset = locateIP(ip);
  144.         if (offset != -1) {
  145.             info = getIPLocation(offset);
  146.         }
  147.         return info;
  148.     }
  149.     // -----------------以下为内部方法
  150.     /**
  151.      * 读取4个字节
  152.      *
  153.      * @param offset
  154.      * @return
  155.      */
  156.     private int readInt(int offset) {
  157.         buffer.position(offset);
  158.         return buffer.getInt();
  159.     }
  160.     private int readInt3(int offset) {
  161.         buffer.position(offset);
  162.         return buffer.getInt() & 0x00FFFFFF;
  163.     }
  164.     /**
  165.      * 从内存映射文件的offset位置得到一个0结尾字符串
  166.      *
  167.      * @param offset
  168.      * @return
  169.      */
  170.     private String readString(int offset) {
  171.         try {
  172.             byte[] buf = new byte[100];
  173.             buffer.position(offset);
  174.             int i;
  175.             for (i = 0, buf[i] = buffer.get(); buf[i] != 0; buf[++i] = buffer
  176.                     .get()) {
  177.             }
  178.             if (i != 0) {
  179.                 return getString(buf, 0, i, "GBK");
  180.             }
  181.         } catch (IllegalArgumentException e) {
  182.         }
  183.         return "";
  184.     }
  185.     /**
  186.      * 从offset位置读取四个字节的ip地址放入ip数组中,读取后的ip为big-endian格式,但是
  187.      * 文件中是little-endian形式,将会进行转换
  188.      *
  189.      * @param offset
  190.      * @param ip
  191.      */
  192.     private void readIP(int offset, byte[] ip) {
  193.         buffer.position(offset);
  194.         buffer.get(ip);
  195.         byte temp = ip[0];
  196.         ip[0] = ip[3];
  197.         ip[3] = temp;
  198.         temp = ip[1];
  199.         ip[1] = ip[2];
  200.         ip[2] = temp;
  201.     }
  202.     /**
  203.      * 把类成员ip和beginIp比较,注意这个beginIp是big-endian的
  204.      *
  205.      * @param ip
  206.      *            要查询的IP
  207.      * @param beginIp
  208.      *            和被查询IP相比较的IP
  209.      * @return 相等返回0,ip大于beginIp则返回1,小于返回-1。
  210.      */
  211.     private int compareIP(byte[] ip, byte[] beginIp) {
  212.         for (int i = 0; i < 4; i++) {
  213.             int r = compareByte(ip[i], beginIp[i]);
  214.             if (r != 0) {
  215.                 return r;
  216.             }
  217.         }
  218.         return 0;
  219.     }
  220.     /**
  221.      * 把两个byte当作无符号数进行比较
  222.      *
  223.      * @param b1
  224.      * @param b2
  225.      * @return 若b1大于b2则返回1,相等返回0,小于返回-1
  226.      */
  227.     private int compareByte(byte b1, byte b2) {
  228.         if ((b1 & 0xFF) > (b2 & 0xFF)) // 比较是否大于
  229.         {
  230.             return 1;
  231.         } else if ((b1 ^ b2) == 0)// 判断是否相等
  232.         {
  233.             return 0;
  234.         } else {
  235.             return -1;
  236.         }
  237.     }
  238.     /**
  239.      * 这个方法将根据ip的内容,定位到包含这个ip国家地区的记录处,返回一个绝对偏移 方法使用二分法查找。
  240.      *
  241.      * @param ip
  242.      *            要查询的IP
  243.      * @return 如果找到了,返回结束IP的偏移,如果没有找到,返回-1
  244.      */
  245.     private int locateIP(byte[] ip) {
  246.         int m = 0;
  247.         int r;
  248.         byte[] b4 = new byte[4];
  249.         // 比较第一个ip项
  250.         readIP(ipBegin, b4);
  251.         r = compareIP(ip, b4);
  252.         if (r == 0) {
  253.             return ipBegin;
  254.         } else if (r < 0) {
  255.             return -1;
  256.         }
  257.         // 开始二分搜索
  258.         for (int i = ipBegin, j = ipEnd; i < j;) {
  259.             m = getMiddleOffset(i, j);
  260.             readIP(m, b4);
  261.             r = compareIP(ip, b4);
  262.             // log.debug(Utils.getIpStringFromBytes(b));
  263.             if (r > 0) {
  264.                 i = m;
  265.             } else if (r < 0) {
  266.                 if (m == j) {
  267.                     j -= IP_RECORD_LENGTH;
  268.                     m = j;
  269.                 } else {
  270.                     j = m;
  271.                 }
  272.             } else {
  273.                 return readInt3(m + 4);
  274.             }
  275.         }
  276.         // 如果循环结束了,那么i和j必定是相等的,这个记录为最可能的记录,但是并非
  277.         // 肯定就是,还要检查一下,如果是,就返回结束地址区的绝对偏移
  278.         m = readInt3(m + 4);
  279.         readIP(m, b4);
  280.         r = compareIP(ip, b4);
  281.         if (r <= 0) {
  282.             return m;
  283.         } else {
  284.             return -1;
  285.         }
  286.     }
  287.     /**
  288.      * 得到begin偏移和end偏移中间位置记录的偏移
  289.      *
  290.      * @param begin
  291.      * @param end
  292.      * @return
  293.      */
  294.     private int getMiddleOffset(int begin, int end) {
  295.         int records = (end - begin) / IP_RECORD_LENGTH;
  296.         records >>= 1;
  297.         if (records == 0) {
  298.             records = 1;
  299.         }
  300.         return begin + records * IP_RECORD_LENGTH;
  301.     }
  302.     /**
  303.      * @param offset
  304.      * @return
  305.      */
  306.     private IPLocation getIPLocation(int offset) {
  307.         IPLocation loc = new IPLocation();
  308.         // 跳过4字节ip
  309.         buffer.position(offset + 4);
  310.         // 读取第一个字节判断是否标志字节
  311.         byte b = buffer.get();
  312.         if (b == AREA_FOLLOWED) {
  313.             // 读取国家偏移
  314.             int countryOffset = readInt3();
  315.             // 跳转至偏移处
  316.             buffer.position(countryOffset);
  317.             // 再检查一次标志字节,因为这个时候这个地方仍然可能是个重定向
  318.             b = buffer.get();
  319.             if (b == NO_AREA) {
  320.                 loc.country = readString(readInt3());
  321.                 buffer.position(countryOffset + 4);
  322.             } else {
  323.                 loc.country = readString(countryOffset);
  324.             }
  325.             // 读取地区标志
  326.             loc.area = readArea(buffer.position());
  327.         } else if (b == NO_AREA) {
  328.             loc.country = readString(readInt3());
  329.             loc.area = readArea(offset + 8);
  330.         } else {
  331.             loc.country = readString(buffer.position() - 1);
  332.             loc.area = readArea(buffer.position());
  333.         }
  334.         return loc;
  335.     }
  336.     /**
  337.      * @param offset
  338.      * @return
  339.      */
  340.     private String readArea(int offset) {
  341.         buffer.position(offset);
  342.         byte b = buffer.get();
  343.         if (b == 0x01 || b == 0x02) {
  344.             int areaOffset = readInt3();
  345.             if (areaOffset == 0) {
  346.                 return "未知地区";
  347.             } else {
  348.                 return readString(areaOffset);
  349.             }
  350.         } else {
  351.             return readString(offset);
  352.         }
  353.     }
  354.     /**
  355.      * 从内存映射文件的当前位置开始的3个字节读取一个int
  356.      *
  357.      * @return
  358.      */
  359.     private int readInt3() {
  360.         return buffer.getInt() & 0x00FFFFFF;
  361.     }
  362.     /**
  363.      * 从ip的字符串形式得到字节数组形式
  364.      *
  365.      * @param ip
  366.      *            字符串形式的ip
  367.      * @return 字节数组形式的ip
  368.      */
  369.     private static byte[] getIpByteArrayFromString(String ip) throws Exception {
  370.         byte[] ret = new byte[4];
  371.         java.util.StringTokenizer st = new java.util.StringTokenizer(ip, ".");
  372.         try {
  373.             ret[0] = (byte) (Integer.parseInt(st.nextToken()) & 0xFF);
  374.             ret[1] = (byte) (Integer.parseInt(st.nextToken()) & 0xFF);
  375.             ret[2] = (byte) (Integer.parseInt(st.nextToken()) & 0xFF);
  376.             ret[3] = (byte) (Integer.parseInt(st.nextToken()) & 0xFF);
  377.         } catch (Exception e) {
  378.             throw e;
  379.         }
  380.         return ret;
  381.     }
  382.     /**
  383.      * 根据某种编码方式将字节数组转换成字符串
  384.      *
  385.      * @param b
  386.      *            字节数组
  387.      * @param offset
  388.      *            要转换的起始位置
  389.      * @param len
  390.      *            要转换的长度
  391.      * @param encoding
  392.      *            编码方式
  393.      * @return 如果encoding不支持,返回一个缺省编码的字符串
  394.      */
  395.     private static String getString(byte[] b, int offset, int len,
  396.                                     String encoding) {
  397.         try {
  398.             return new String(b, offset, len, encoding);
  399.         } catch (UnsupportedEncodingException e) {
  400.             return new String(b, offset, len);
  401.         }
  402.     }
  403.     /**
  404.      * @param ip
  405.      *            ip的字节数组形式
  406.      * @return 字符串形式的ip
  407.      */
  408.     private static String getIpStringFromBytes(byte[] ip) {
  409.         StringBuffer sb = new StringBuffer();
  410.         sb.append(ip[0] & 0xFF);
  411.         sb.append('.');
  412.         sb.append(ip[1] & 0xFF);
  413.         sb.append('.');
  414.         sb.append(ip[2] & 0xFF);
  415.         sb.append('.');
  416.         sb.append(ip[3] & 0xFF);
  417.         return sb.toString();
  418.     }
  419.     public class IPLocation {
  420.         private String country;// 所在国家
  421.         private String area;// 所在地区
  422.         public IPLocation() {
  423.         }
  424.         public IPLocation(String country, String area) {
  425.             this.country = country;
  426.             this.area = area;
  427.         }
  428.         public IPLocation getCopy() {
  429.             return new IPLocation(country, area);
  430.         }
  431.         public String getArea() {
  432.             return " CZ88.NET".equals(area) ? "" : area;
  433.         }
  434.         public void setArea(String area) {
  435.             this.area = area;
  436.         }
  437.         public String getCountry() {
  438.             return " CZ88.NET".equals(country) ? "" : country;
  439.         }
  440.         public void setCountry(String country) {
  441.             this.country = country;
  442.         }
  443.     }
  444.     /**
  445.      * * 一条IP范围记录,不仅包括国家和区域,也包括起始IP和结束IP *
  446.      *
  447.      */
  448.     public class IPEntry {
  449.         public String beginIp;
  450.         public String endIp;
  451.         public String country;
  452.         public String area;
  453.         /**
  454.          * 构造函数
  455.          */
  456.         public IPEntry() {
  457.         }
  458.         @Override
  459.         public String toString() {
  460.             return new StringBuilder(this.area).append(";")
  461.                     .append(this.country).append(";").append("IP范围:")
  462.                     .append(beginIp).append("-").append(endIp).toString();
  463.         }
  464.     }
  465. }

工具类来自网络,我们只需要调用其中的的 getAddress() 方法

 

4、IpServiceImpl.java

  1. package com.liuyanzhao.forum.service.impl;
  2. import com.liuyanzhao.forum.util.IPSeekerUtil;
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5. import org.springframework.beans.factory.annotation.Value;
  6. import org.springframework.stereotype.Service;
  7. import java.io.*;
  8. /**
  9.  * @author 言曌
  10.  * @date 2018/4/9 下午9:32
  11.  */
  12. @Service
  13. public class IpServiceImpl {
  14.     private final Logger logger = LoggerFactory.getLogger(this.getClass());
  15.     private static IPSeekerUtil ipSeeker;
  16.     @Value("${qqwry.dat.path}")
  17.     private String filepath;
  18.     public String getIpArea(String ip) {
  19.         if (ipSeeker == null) {
  20.             try {
  21.                 ipSeeker = new IPSeekerUtil(new File(filepath));
  22.             } catch (Exception e) {
  23.                 logger.error("IP地址库实例化出错", e);
  24.             }
  25.         }
  26.         return ipSeeker.getAddress(ip);
  27.     }
  28. }

为了代码的简洁,删除了实现 IpService

 

5、测试示例

IpServiceImplTest.java

  1. package com.liuyanzhao.forum.service.impl;
  2. import org.junit.Test;
  3. import org.junit.runner.RunWith;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.boot.test.context.SpringBootTest;
  6. import org.springframework.test.context.junit4.SpringRunner;
  7. /**
  8.  * @author 言曌
  9.  * @date 2018/4/9 下午9:34
  10.  */
  11. @SpringBootTest
  12. @RunWith(SpringRunner.class)
  13. public class IpServiceImplTest {
  14.     @Autowired
  15.     private IpServiceImpl ipService;
  16.     @Test
  17.     public void testGetArea() {
  18.         Long startTime = System.currentTimeMillis();
  19.         //调用本地数据库,测试三次,分别耗时 2ms 6ms 3ms
  20.         System.out.println(ipService.getIpArea("39.176.195.166"));
  21.         System.out.println("总共耗时:"+(System.currentTimeMillis()-startTime)+"ms");
  22.     }
  23. }

 

二、调用淘宝IP地址库接口

1、IpServiceImpl.java

  1. package com.liuyanzhao.forum.service.impl;
  2. import com.alibaba.fastjson.JSONObject;
  3. import org.apache.commons.lang.StringEscapeUtils;
  4. import org.slf4j.Logger;
  5. import org.slf4j.LoggerFactory;
  6. import org.springframework.stereotype.Service;
  7. import java.io.*;
  8. import java.net.HttpURLConnection;
  9. import java.net.MalformedURLException;
  10. import java.net.URL;
  11. /**
  12.  * @author 言曌
  13.  * @date 2018/4/9 下午9:32
  14.  */
  15. @Service
  16. public class IpServiceImpl {
  17.     private final Logger logger = LoggerFactory.getLogger(this.getClass());
  18.     public String getIpArea2(String ip) {
  19.         String path = "http://ip.taobao.com/service/getIpInfo.php?ip=" + ip;
  20.         String inputline = "";
  21.         String info = "";
  22.         try {
  23.             URL url = new URL(path);
  24.             HttpURLConnection conn = (HttpURLConnection) url.openConnection();
  25.             conn.setReadTimeout(10 * 1000);
  26.             conn.setRequestMethod("GET");
  27.             InputStreamReader inStream = new InputStreamReader(conn.getInputStream(), "UTF-8");
  28.             BufferedReader buffer = new BufferedReader(inStream);
  29.             while ((inputline = buffer.readLine()) != null) {
  30.                 info += inputline;
  31.             }
  32.         } catch (MalformedURLException e) {
  33.             e.printStackTrace();
  34.         } catch (IOException e) {
  35.             e.printStackTrace();
  36.         }
  37.         JSONObject jsonob = JSONObject.parseObject((JSONObject.parseObject(info).getString("data")));
  38.         String city = StringEscapeUtils.escapeSql(jsonob.getString("city"));
  39.         return city;
  40.     }
  41. }

为了代码简洁,省去了实现 IpService

 

2、测试示例

  1. package com.liuyanzhao.forum.service.impl;
  2. import org.junit.Test;
  3. import org.junit.runner.RunWith;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.boot.test.context.SpringBootTest;
  6. import org.springframework.test.context.junit4.SpringRunner;
  7. /**
  8.  * @author 言曌
  9.  * @date 2018/4/9 下午9:34
  10.  */
  11. @SpringBootTest
  12. @RunWith(SpringRunner.class)
  13. public class IpServiceImplTest {
  14.     @Autowired
  15.     private IpServiceImpl ipService;
  16.     @Test
  17.     public void testGetArea() {
  18.         Long startTime = System.currentTimeMillis();
  19.         //调用淘宝IP接口,测试三次,分别耗时 168ms 161ms 156ms
  20.         System.out.println(ipService.getIpArea2("39.176.195.166"));
  21.         System.out.println("总共耗时:"+(System.currentTimeMillis()-startTime)+"ms");
  22.     }
  23. }

 

  • 微信
  • 交流学习,有偿服务
  • weinxin
  • 博客/Java交流群
  • 资源分享,问题解决,技术交流。群号:590480292
  • weinxin
言曌

发表评论

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: