纯真IP地址数据库qqwry.dat解析

最新推荐文章于 2024-04-26 19:52:36 发布
最新推荐文章于 2024-04-26 19:52:36 发布
阅读量367 收藏
点赞数
文章标签： 数据库 java
原文链接：http://www.cnblogs.com/difeng/p/7172081.html
版权

ip地址数据库，在现在互联网时代非常有用，比如大型网站的用户安全保护系统，就常常会根据ip反查的信息，甄别账号的一些不安全登录行为，比如跨区域登录问题等。ip其实关联了一些有信息，比如区域，所在运营商，一些收录全的，甚至包括具体经纬度，像百度的IP定位api就比较全。下面来介绍一下“ 纯真IP地址数据库qqwry”的格式以及解析

以下是“ 纯真IP地址数据库qqwry”官网对其的介绍。

纯真版IP地址数据库是当前网络上最权威、地址最精确、IP记录以及网吧数据最多的IP地址数据库。收集了包括中国电信、中国移动、中国联通、铁通、长城宽带等各 ISP 的最新准确 IP 地址数据。通过大家的共同努力打造一个没有未知数据，没有错误数据的QQ IP。IP数据库每5天更新一次，请大家定期更新最新的IP数据库！

格式

+———-+
| 文件头 | (8字节)
+———-+
| 记录区 | (不定长)
+———-+
| 索引区 | (大小由文件头决定)
+———-+

使用java语言解析的两种思路：

  • 使用内存映射文件方式读取，使用java的MappedByteBuffer 将原数据文件映射到MappedByteBuffer对象中，然后通过MappedByteBuffer 提供的字节读取方式实现ip的查找。搜索是在索引区使用二分法

  • 使用byte数组读取，及将二进制的数据库信息全都按顺序读入到一个数组中，由于数据是有格式的，我们便可计算根据索引区和记录区在数组中的位置，当查询ip时，从数组中的索引区开始通过二分查找方式找到IP地址对应的国家和区域的位置，然后从数组中取出地区信息。

热升级思路：

使用一个可调度的单线程的线程池，线程定时检测qqwry.dat文件是否修改，若修改则重新将数据重新载入，载入过程可使用可重入锁ReentrantLock来锁住资源，避免在更新的过程中脏查询

两种解析方式的实现源码如下：
方式一（MappedByteBuffer ）：

package com.difeng.qqwry1;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteOrder;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
/**
 * @Description:ip定位查找工具(使用内存映射文件方式读取，线程安全)
 * @author:difeng
 * @date:2016年12月11日
 */
public class IPLocation {

    private static final int IP_RECORD_LENGTH = 7;

    private static final byte REDIRECT_MODE_1 = 0x01;

    private static final byte REDIRECT_MODE_2 = 0x02;

    private MappedByteBuffer mbbFile;

    private static Long lastModifyTime = 0L;

    public static boolean enableFileWatch = false;

    private static ReentrantLock lock = new ReentrantLock();

    private File qqwryFile;

    private long firstIndexOffset;

    private long lastIndexOffset;

    private long totalIndexCount;

    public IPLocation(String filePath) throws Exception {
        this.qqwryFile = new File(filePath);
        load();
        if (enableFileWatch) {
            watch();
        }
    }

    private void watch(){
        Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                long time = qqwryFile.lastModified();
                if (time > lastModifyTime) {
                    lastModifyTime = time;
                    try {
                        load();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }, 1000L, 30000L, TimeUnit.MILLISECONDS);
    }

    public long read4ByteAsLong(long pos) {
        mbbFile.position((int)pos);
        return 0xFFFFFFFFL & mbbFile.getInt();
    }

    public long read3ByteAsLong(long pos){
        mbbFile.position((int)pos);
        return 0xFFFFFFL & mbbFile.getInt();
    }


    @SuppressWarnings("resource")
    private void load() throws Exception {
        lastModifyTime = qqwryFile.lastModified();
        lock.lock();
        try {
            mbbFile =  new RandomAccessFile(qqwryFile, "r")
                    .getChannel()
                    .map(FileChannel.MapMode.READ_ONLY, 0, qqwryFile.length());
            mbbFile.order(ByteOrder.LITTLE_ENDIAN);
            firstIndexOffset = read4ByteAsLong(0);
            lastIndexOffset = read4ByteAsLong(4);
            totalIndexCount = (lastIndexOffset - firstIndexOffset) / IP_RECORD_LENGTH + 1;
        } finally {
            lock.unlock();
        }
    }
    
    /**
     * @Description:将“.”号分隔的字符串转换为long类型的数字，字节序例如:
     *   ip:182.92.240.48  16进制表示(B6.5C.F0.30)
     *   转换后ip的16进制表示:0xB65CF030
     * @param ipStr
     * @return:long
     */
    private static long inet_pton(String ipStr) {
        if(ipStr == null){
            throw new NullPointerException("ip不能为空");
        }
        String [] arr = ipStr.split("\\.");
        long ip = (Long.parseLong(arr[0])  & 0xFFL) << 24 & 0xFF000000L;
        ip |=  (Long.parseLong(arr[1])  & 0xFFL) << 16 & 0xFF0000L;
        ip |=  (Long.parseLong(arr[2])  & 0xFFL) << 8 & 0xFF00L;
        ip |=  (Long.parseLong(arr[3])  & 0xFFL);
        return ip;
    }

    private long search(long ip) {
        long low = 0;
        long high = totalIndexCount;
        long mid = 0;
        while(low <= high) {
            mid = (low + high) >>> 1 ;
            long indexIP = read4ByteAsLong(firstIndexOffset + (mid - 1) * IP_RECORD_LENGTH);
            long nextIndexIP =  read4ByteAsLong(firstIndexOffset + mid * IP_RECORD_LENGTH);
            if(indexIP <= ip && ip < nextIndexIP) {
                return read3ByteAsLong(firstIndexOffset + (mid - 1) * IP_RECORD_LENGTH + 4);
            } else {
                if(ip > indexIP) {
                    low = mid + 1;
                } else if(ip < indexIP) {
                    high = mid - 1;
                }
            }
        }
        return -1;
    }

    private Location readIPLocation(long offset) {
        try {
            mbbFile.position((int)offset + 4);
            Location loc = new Location();
            byte redirectMode = mbbFile.get();
            if (redirectMode == REDIRECT_MODE_1) {
                long countryOffset = read3ByteAsLong((int)offset + 5);
                mbbFile.position((int)countryOffset);
                redirectMode = mbbFile.get();
                if (redirectMode == REDIRECT_MODE_2) {
                    loc.country = readString(read3ByteAsLong(countryOffset + 1));
                    mbbFile.position((int)countryOffset + 4);
                } else {
                    loc.country = readString(countryOffset);
                }
                loc.area = readArea(mbbFile.position());
            } else if (redirectMode == REDIRECT_MODE_2) {
                loc.country = readString(read3ByteAsLong((int)offset + 5));
                loc.area = readArea((int)offset + 8);
            } else {
                loc.country = readString(mbbFile.position() - 1);
                loc.area = readArea(mbbFile.position());
            }
            return loc;
        } catch (Exception e) {
            return null;
        }
    }

    private String readArea(int offset) {
        mbbFile.position(offset);
        byte redirectMode = mbbFile.get();
        if (redirectMode == REDIRECT_MODE_1 || redirectMode == REDIRECT_MODE_2) {
            long areaOffset = read3ByteAsLong((int)offset + 1);
            if (areaOffset == 0){
                return "";
            } else {
                return readString(areaOffset);
            }
        } else {
            return readString(offset);
        }
    }

    private String readString(long offset) {
        try {
            mbbFile.position((int)offset);
            byte[] buf = new byte[128];
            int i;
            for (i = 0, buf[i] = mbbFile.get(); buf[i] != 0; buf[++i] = mbbFile.get());
            
            if (i != 0){
                return new String(buf, 0, i, "GBK");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "";
    }

    public  Location fetchIPLocation(String ip) {
        lock.lock();
        try {
            long offset = search(inet_pton(ip));
            if(offset != -1){
                return readIPLocation(offset);
            }
        } finally {
            lock.unlock();
        }
        return null;
    }
}

方式二（数组方式）：

package com.difeng.qqwry2;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
/**
 * @Description:ip定位(使用byte数据方式读取)
 * @author:difeng
 * @date:2016年12月13日
 */
public class IPLocation {
    
    private  byte[] data;
    
    private  long firstIndexOffset;
    
    private  long lastIndexOffset;
    
    private  long totalIndexCount;
    
    private static final byte REDIRECT_MODE_1 = 0x01;
    
    private static final byte REDIRECT_MODE_2 = 0x02;
    
    static   final long IP_RECORD_LENGTH = 7;
    
    private static ReentrantLock lock = new ReentrantLock();
    
    private static Long lastModifyTime = 0L;

    public static boolean enableFileWatch = false;
    
    private File qqwryFile;
    
    public IPLocation(String  filePath) throws Exception {
        this.qqwryFile = new File(filePath);
        load();
        if(enableFileWatch){
            watch();
        }
    }
    
    private void watch() {
        Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                long time = qqwryFile.lastModified();
                if (time > lastModifyTime) {
                    lastModifyTime = time;
                    try {
                        load();
                        System.out.println("reload");
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }, 1000L, 5000L, TimeUnit.MILLISECONDS);
    }
    
    private void load() throws Exception {
        lastModifyTime = qqwryFile.lastModified();
        ByteArrayOutputStream out = null;
        FileInputStream in = null;
        lock.lock();
        try {
            out = new ByteArrayOutputStream();
            byte[] b = new byte[1024];
            in = new FileInputStream(qqwryFile);
            while(in.read(b) != -1){
                out.write(b);
            }
            data = out.toByteArray();
            firstIndexOffset = read4ByteAsLong(0);
            lastIndexOffset = read4ByteAsLong(4);
            totalIndexCount = (lastIndexOffset - firstIndexOffset) / IP_RECORD_LENGTH + 1;
            in.close();
            out.close();
        } finally {
            try {
                if(out != null) {
                    out.close();
                }
                if(in != null) {
                    in.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            lock.unlock();
        }
    }
    
    private long read4ByteAsLong(final int  offset) {
        long val = data[offset] & 0xFF;
        val |= (data[offset + 1] << 8L) & 0xFF00L;
        val |= (data[offset + 2] << 16L) & 0xFF0000L;
        val |= (data[offset + 3] << 24L) & 0xFF000000L;
        return val;
    }

    private long read3ByteAsLong(final int offset) {
        long val = data[offset] & 0xFF;
        val |= (data[offset + 1] << 8) & 0xFF00;
        val |= (data[offset + 2] << 16) & 0xFF0000;
        return val;
    }
    
    private long search(long ip) {
        long low = 0;
        long high = totalIndexCount;
        long mid = 0;
        while(low <= high){
            mid = (low + high) >>> 1 ;
            long indexIP = read4ByteAsLong((int)(firstIndexOffset + (mid - 1) * IP_RECORD_LENGTH));
            long indexIPNext = read4ByteAsLong((int)(firstIndexOffset + mid * IP_RECORD_LENGTH));
            if(indexIP <= ip && ip < indexIPNext) {
                return read3ByteAsLong((int)(firstIndexOffset + (mid - 1) * IP_RECORD_LENGTH + 4));
            } else {
                if(ip > indexIP) {
                    low = mid + 1;
                } else if (ip < indexIP) {
                    high = mid - 1;
                }
            }
        }
        return -1;
    }
    
    public Location fetchIPLocation(String ip) {
        long numericIp = inet_pton(ip);
        lock.lock();
        long offset = search(numericIp);
        try{
            if(offset != -1) {
                return readIPLocation((int)offset);
            }
        } finally {
            lock.unlock();
        }
        return null;
    }
    
    private Location readIPLocation(final int offset) {
        final Location loc = new Location();
        try {
            byte redirectMode = data[offset + 4];
            if (redirectMode == REDIRECT_MODE_1) {
                long countryOffset = read3ByteAsLong((int)offset + 5);
                redirectMode = data[(int)countryOffset];
                if (redirectMode == REDIRECT_MODE_2) {
                    final QQwryString country = readString((int)read3ByteAsLong((int)countryOffset + 1));
                    loc.country = country.string;
                    countryOffset = countryOffset + 4;
                } else {
                    final QQwryString country = readString((int)countryOffset);
                    loc.country = country.string;
                    countryOffset += country.byteCountWithEnd;
                }
                loc.area = readArea((int)countryOffset);
            } else if (redirectMode == REDIRECT_MODE_2) {
                loc.country = readString((int)read3ByteAsLong((int)offset + 5)).string;
                loc.area = readArea((int)offset + 8);
            } else {
                final QQwryString country = readString((int)offset + 4);
                loc.country = country.string;
                loc.area = readArea((int)offset + 4 + country.byteCountWithEnd);
            }
            return loc;
        } catch (Exception e) {
            return null;
        }
    }

    private String readArea(final int offset) {
        byte redirectMode = data[offset];
        if (redirectMode == REDIRECT_MODE_1 || redirectMode == REDIRECT_MODE_2) {
            long areaOffset = read3ByteAsLong((int)offset + 1);
            if (areaOffset == 0) {
                return "";
            } else {
                return readString((int)areaOffset).string;
            }
        } else {
            return readString(offset).string;
        }
    }
    
    private QQwryString readString(int offset) {
        int pos = offset;
        final byte[] b = new byte[128];
        int i;
        for (i = 0, b[i] = data[pos++]; b[i] != 0; b[++i] = data[pos++]);
        try{
               return new QQwryString(new String(b,0,i,"GBK"),i + 1);
        } catch(UnsupportedEncodingException e) {
            return new QQwryString("",0);
        }
    }
    
     /**
     * @Description:“.”号分隔的字符串转换为long类型的数字
     * @param ipStr 
     * @return:long
     */
    private static long inet_pton(String ipStr) {
        if(ipStr == null){
            throw new NullPointerException("ip不能为空");
        }
        String [] arr = ipStr.split("\\.");
        long ip = (Long.parseLong(arr[0])  & 0xFFL) << 24 & 0xFF000000L;
        ip |=  (Long.parseLong(arr[1])  & 0xFFL) << 16 & 0xFF0000L;
        ip |=  (Long.parseLong(arr[2])  & 0xFFL) << 8 & 0xFF00L;
        ip |=  (Long.parseLong(arr[3])  & 0xFFL);
        return ip;
    }
    
    private class QQwryString{
        
        public final String string;
        
        public final int byteCountWithEnd;
        
        public QQwryString(final String string,final int byteCountWithEnd) {
            this.string = string;
            this.byteCountWithEnd = byteCountWithEnd;
        }
        
        @Override
        public String toString() {
            return string;
        }
        
    }
}

以上为主要代码，获取全部代码请点击全部代码

使用

final IPLocation ipLocation = new IPLocation(filePath);
Location loc = ipl.fetchIPLocation("182.92.240.50");
System.out.printf("%s %s",loc.country,loc.area);

格式改进

由于原格式中读取地区记录时采用重定向，有些繁琐。去掉之后格式更简单，国家和地区单独存放,索引里分别记录的国家和地区的地址。
新格式如下：

+----------+
| 文件头 | (8字节)
+----------+
| 记录区 | (不定长)
+----------+
| 索引区 | (大小由文件头决定)
+----------+
文件头：
+------------------------------+-----------------------------+
| first index position(4 bytes)|last index position(4 bytes) |
+------------------------------+-----------------------------+
记录区：
+------------------+----------+------------------+----------+-----
| country1(n bytes)|\0(1 byte)| country2(n bytes)|\0(1 byte)|...
+------------------+----------+------------------+----------+-----
+------------------+----------+------------------+----------+-----
| area1(n bytes) |\0(1 byte)| area2(n bytes) |\0(1 byte)|...
+------------------+----------+------------------+----------+-----
索引区：
+------------+-------------------------+------------------------+
|ip1(4 bytes)|country position(3 bytes)| area position(3 bytes) |...
+------------+-------------------------+------------------------+
转换方法：

final IPFileConvertor convertor = new 
IPFileConvertor(IPFileConvertor.class.getResource("/qqwry.dat").getPath(),"./qqwry.dat");
convertor.convert();
新格式使用方法和之前的一致，使用com.difeng.convert包下的解析类IPLocation解析即可。

相关连接：
qqwry下载： qqwry
全球ip地址库（收费）：IPLocation

转载于:https://www.cnblogs.com/difeng/p/7172081.html

weixin_30376453
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
珊瑚QQ提取的 qqwry IP库 dat文件, 可以结合PHP类使用
12-22
IP库 .dat 珊瑚QQ提取的 qqwry IP库 dat文件, 可以结合PHP类使用
纯真ip库 QQWry.dat文件解析
SauryN的博客
08-29 985
QQWry.dat文件解析
qqwry - 纯真ip库的golang服务
weixin_33919950的博客
05-10 226
qqwry 纯真 IP 库的一个服务。通过http提供一个ip地址归属地查询支持 软件介绍 我们大家做网站的时候，都会需要将用户的IP地址转换为归属地址功能，而之前的作法大都是从硬盘的数据文件中读取，这样不太高效。我这次将纯真IP库直接加载到内存中，并以http服务的方式提供接口出来。这样方便自己项目中所有的程序都能方便的接口IP查询功能了。 安装 go安装 go get github...
易语言读取QQWary地理位置
ASP.NET的博客
08-11 875
易语言查询QQWary.dat内的地理位置
QQwry.dat 数据结构 存储结构 解析[C#代码]
weixin_30567471的博客
11-11 153
存储格式： A.文件头(大小8字节), B.记录区(不定长)，C.索引区(大小由文件头决定)A.文件头是8个字节长度，前四个字节存储了第一条索引的绝对地址， 后四个字节存储了最后一条索引的绝对地址。 (2^32字节=4GB)B.记录的格式是[IP地址][国家记录][地区记录]: ip:4字节, 国家记录(字符串,0结尾), 地区记录(字符串,0结尾) [字段形式] 国家...
ruoyi集成qqwry实现本地ip地址解析
qq_25953361的博客
05-30 214
ruoyi集成qqwry实现本地ip地址解析
QQwry格式
这就是我自己
08-18 8427
式如下: A。文件头，共8字节 B。若干条记录的结束地址+国家和区域 C。按照从小到大排列的若干条起始地址+结束地址偏移，定长，7字节 D。所有的IP都是用4字节整数记录的，并且遵照Intel次序，高位在后，低位在前。 E。所有偏移量都是绝对偏移，就是从文件最开头计算。 F。除了文件头用了两个4字节偏移，其余偏移量都用3字节。 G。所有的偏移量也是低位在前，高位在后 H。采用了一些字符串压缩技
利用纯真数据库根据IP定位地区
Aleyns的博客
12-20 4695
IP地址是每台计算机的唯一标识，也是每台计算机通信所必备的。因此，根据IP地址定位地址也是一个很常见的功能。
纯真IP库(qqwry.dat)
03-20
纯真IP库(qqwry.dat) java解析纯真IP数据库……
最新QQWry.Dat 下载
10-19
QQWry.Dat 是免费的 IP 库 相对于webservices，在本地用ip库根据ip判断地区是最快的。 net部落 http://www.ntbl.net
qqwry:纯真IP地址库qqwry.dat解析代码
05-22
纯真IP地址库qqwry.dat解析代码 使用两种方式实现： 使用内存映射文件方式读取(位于com.difeng.qqwry1包下) 使用byte数组读取(位于com.difeng.qqwry2包下) 两种实现，使用方法一致: final IPLocation ipLocation = ...
纯真IP数据库 QQwry.dat 2021年04月21日
04-28
记录总数：529072条 更新日期：2021年04月21日 数据库版本：纯真
最新纯真ip数据库qqwry.dat
08-06
最新纯真ip数据库qqwry.dat
PHP获取IP地址所在地信息的实例(使用纯真IP数据库qqwry.dat)
01-20
echo ip2long($data); function getIP() { if(getenv(HTTP_CLIENT_IP) && strcasecmp(getenv(HTTP_CLIENT_IP), unknown)) $ip = getenv(HTTP_CLIENT_IP); elseif(getenv(HTTP_X_FORWARDED_FOR) && strcasecmp...
纯真IP数据库QQwry.dat
08-17
纯真IP数据库QQwry.dat可供网站、软件等相关程序语言调用读取指定IP的城市地区信息
【kettle001】访问国产达梦数据库并处理数据至execl文件
kngines
04-22 423
一直以来想写下基于kettle的系列文章，作为较火的数据ETL工具，也是日常项目开发中常用的一款工具，最近刚好挤时间梳理、总结下这块儿的知识体系。熟悉、梳理、总结下达梦（DM）关系型数据库相关知识体系。
探秘MySQL主从复制的多种实现方式
最新发布
todoitbo的博客
04-26 649
本文将深入探讨MySQL主从复制的多种实现方式，包括基于语句、基于行和混合模式等。无论您是初学者还是有经验的数据库管理员，都能通过本文全面了解MySQL主从复制技术的多样化选择，从而提高数据库的可用性和性能。
【ROMA解决方案和功能架构】
数据也是生产力，保持热爱，奔赴山海！
04-23 718
1、基于ROMA融合集成平台，实现企业应用、数据、API 、OT设备、云服务、合作伙伴应用之间的集成连接。2、ROMA主要包含四个组件：数据集成（Fast Data Integration，简称FDI）、服务集成（API Connect，简称APIC）、消息集成（Message Queue Service，简称MQS）、设备集成（LINK）。
qqwry.dat下载
12-22
qqwry.dat 是一个 IP 地址归属地查询数据库文件，可以用于查询 IP 地址的所在地。 要下载 qqwry.dat 文件，可以通过以下几种方式： 1. 在互联网上搜索 qqwry.dat 文件的下载链接，从可靠的网站或平台下载。可以尝试在搜索引擎上搜索“qqwry.dat 文件下载”等关键词，找到下载链接后进行下载。 2. 到一些知名的 IP 地址查询网站，例如 IP138、IP地址查询、淘宝IP地址库等，这些网站通常会提供 qqwry.dat 文件的下载服务。 3. 从一些技术社区或论坛下载，例如 GitHub、CSDN、Stack Overflow 等。这些平台上可能会有程序员或开发者共享的 qqwry.dat 文件下载链接。 下载 qqwry.dat 文件时，需要注意文件的来源和真实性，尽量选择官方或可信任的渠道进行下载，以避免下载到病毒或损坏的文件。同时，下载后可以使用相关的 IP 地址查询工具进行测试，确保文件的有效性和完整性。 总之，下载 qqwry.dat 文件时需要谨慎选择下载渠道，并在下载后进行验证，以确保文件的安全性和可靠性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值