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

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

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



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

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



5、测试示例

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


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


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

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



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











历史上的今天
四月
09日
  • 微信
  • 交流学习，资料分享
  • weinxin
  • 个人淘宝
  • 店铺名：言曌博客咨询部

  • (部分商品未及时上架淘宝)
avatar

发表评论

avatar 登录者：匿名
匿名评论，评论回复后会有邮件通知

  

已通过评论：0   待审核评论数：0