java 通过 qqwry.dat 解析ip所在地区，qqwry最好隔一段时间更换一个最新的文件

最新推荐文章于 2024-03-17 09:41:17 发布
最新推荐文章于 2024-03-17 09:41:17 发布
阅读量440 收藏
点赞数
文章标签： ip java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43356053/article/details/83503636
版权

IPEntry.java
package com.jk.utils.readDat;

/** *

  • 一条IP范围记录，不仅包括国家和区域，也包括起始IP和结束IP *
    */
    public class IPEntry {
    public String beginIp;
    public String endIp;
    public String country;
    public String area;

    /**

    • 构造函数
      */

public IPEntry() {
beginIp = endIp = country = area = “”;
}

public String toString(){
   return        this.area+"  "+this.country+"IP范围:"+this.beginIp+"-"+this.endIp;
}

}
IPSeeker.java

package com.jk.utils.readDat;

/*

  • LumaQQ - Java QQ Client
  • Copyright © 2004 luma < stubma@163.com>
  • This program is free software; you can redistribute it and/or modify
  • it under the terms of the GNU General Public License as published by
  • the Free Software Foundation; either version 2 of the License, or
  • (at your option) any later version.
  • This program is distributed in the hope that it will be useful,
  • but WITHOUT ANY WARRANTY; without even the implied warranty of
  • MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  • GNU General Public License for more details.
  • You should have received a copy of the GNU General Public License
  • along with this program; if not, write to the Free Software
  • Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
    */

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteOrder;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**

    • 用来读取QQwry.dat文件，以根据ip获得好友位置，QQwry.dat的格式是

  • 一. 文件头，共8字节

    1. 第一个起始IP的绝对偏移， 4字节
    1. 最后一个起始IP的绝对偏移， 4字节

  • 二. "结束地址/国家/区域"记录区

  • 四字节ip地址后跟的每一条记录分成两个部分

    1. 国家记录
    1. 地区记录

  • 但是地区记录是不一定有的。而且国家记录和地区记录都有两种形式

    1. 以0结束的字符串
    1. 4个字节，一个字节可能为0x1或0x2

  • a. 为0x1时，表示在绝对偏移后还跟着一个区域的记录，注意是绝对偏移之后，而不是这四个字节之后

  • b. 为0x2时，表示在绝对偏移后没有区域记录

  • 不管为0x1还是0x2，后三个字节都是实际国家名的文件内绝对偏移

  • 如果是地区记录，0x1和0x2的含义不明，但是如果出现这两个字节，也肯定是跟着3个字节偏移，如果不是

  • 则为0结尾字符串

  • 三. "起始地址/结束地址偏移"记录区

    1. 每条记录7字节，按照起始地址从小到大排列

  • a. 起始IP地址，4字节

  • b. 结束ip地址的绝对偏移，3字节

  • 注意，这个文件里的ip地址和所有的偏移量均采用little-endian格式，而java是采用

  • big-endian格式的，要注意转换
    /
    public class IPSeeker {
    /    *

      • 用来封装ip相关信息，目前只有两个字段，ip所在的国家和地区
    • @author syh
      */
      private static Logger logger = LoggerFactory.getLogger(IPSeeker.class);
      private static IPSeeker ipSeeker;

    public static IPSeeker getInstance() {
    if (ipSeeker == null) {
    ipSeeker = new IPSeeker();
    }
    return ipSeeker;
    }

    private class IPLocation {
    public String country;
    public String area;

     public IPLocation() {
 	country = area = "";
 }

 public IPLocation getCopy() {
 	IPLocation ret = new IPLocation();
 	ret.country = country;
 	ret.area = area;
 	return ret;
 }

    }

    private static final String IP_FILE = IPSeeker.class.getResource(“qqwry.dat”).toString().substring(5);

    // 一些固定常量，比如记录长度等等
    private static final int IP_RECORD_LENGTH = 7;
    private static final byte AREA_FOLLOWED = 0x01;
    private static final byte NO_AREA = 0x2;

    // 用来做为cache，查询一个ip时首先查看cache，以减少不必要的重复查找
    private Hashtable ipCache;
    // 随机文件访问类
    private RandomAccessFile ipFile;
    // 内存映射文件
    private MappedByteBuffer mbb;

    // 起始地区的开始和结束的绝对偏移
    private long ipBegin, ipEnd;
    // 为提高效率而采用的临时变量
    private IPLocation loc;
    private byte[] buf;
    private byte[] b4;
    private byte[] b3;
    private boolean fileRead = true;

    /**

    • 私有构造函数
      */
      public IPSeeker() {
      ipCache = new Hashtable();
      loc = new IPLocation();
      buf = new byte[100];
      b4 = new byte[4];
      b3 = new byte[3];
      try {
      ipFile = new RandomAccessFile(IP_FILE, “r”);
      } catch (FileNotFoundException e) {
      ipFile = null;
      fileRead = false;

      }
      // 如果打开文件成功，读取文件头信息
      if (ipFile != null) {
      try {
      ipBegin = readLong4(0);
      ipEnd = readLong4(4);
      if (ipBegin == -1 || ipEnd == -1) {
      ipFile.close();
      ipFile = null;
      }
      } catch (IOException e) {
      ipFile = null;
      fileRead = false;
      }
      }
      }

    /**

    • 给定一个地点的不完全名字，得到一系列包含s子串的IP范围记录
    • @param s 地点子串
    • @return 包含IPEntry类型的List
      */
      public List getIPEntriesDebug(String s) {
      List ret = new ArrayList();
      long endOffset = ipEnd + 4;
      for (long offset = ipBegin + 4; offset <= endOffset; offset += IP_RECORD_LENGTH) {
      // 读取结束IP偏移
      long temp = readLong3(offset);
      // 如果temp不等于-1，读取IP的地点信息
      if (temp != -1) {
      IPLocation loc = getIPLocation(temp);
      // 判断是否这个地点里面包含了s子串，如果包含了，添加这个记录到List中，如果没有，继续
      if (loc.country.indexOf(s) != -1 || loc.area.indexOf(s) != -1) {
      IPEntry entry = new IPEntry();
      entry.country = loc.country;
      entry.area = loc.area;
      // 得到起始IP
      readIP(offset - 4, b4);
      entry.beginIp = IPProcessUtils.getIpStringFromBytes(b4);
      // 得到结束IP
      readIP(temp, b4);
      entry.endIp = IPProcessUtils.getIpStringFromBytes(b4);
      // 添加该记录
      ret.add(entry);
      }
      }
      }
      return ret;
      }

    /**

    • 给定一个地点的不完全名字，得到一系列包含s子串的IP范围记录

    • @param s 地点子串

    • @return 包含IPEntry类型的List
      */
      public List getIPEntries(String s) {
      List ret = new ArrayList();
      try {
      // 映射IP信息文件到内存中
      if (mbb == null) {
      FileChannel fc = ipFile.getChannel();
      mbb = fc.map(FileChannel.MapMode.READ_ONLY, 0, ipFile.length());
      mbb.order(ByteOrder.LITTLE_ENDIAN);
      }

       int endOffset = (int) ipEnd;
 for (int offset = (int) ipBegin + 4; offset <= endOffset; offset += IP_RECORD_LENGTH) {
 	int temp = readInt3(offset);
 	if (temp != -1) {
 		IPLocation loc = getIPLocation(temp);
 		// 判断是否这个地点里面包含了s子串，如果包含了，添加这个记录到List中，如果没有，继续
 		if (loc.country.indexOf(s) != -1
 				|| loc.area.indexOf(s) != -1) {
 			IPEntry entry = new IPEntry();
 			entry.country = loc.country;
 			entry.area = loc.area;
 			// 得到起始IP
 			readIP(offset - 4, b4);
 			entry.beginIp = IPProcessUtils.getIpStringFromBytes(b4);
 			// 得到结束IP
 			readIP(temp, b4);
 			entry.endIp = IPProcessUtils.getIpStringFromBytes(b4);
 			// 添加该记录
 			ret.add(entry);
 		}
 	}
 }

      } catch (IOException e) {
      logger.error(e.getMessage());
      }
      return ret;
      }

    /**

    • 从内存映射文件的offset位置开始的3个字节读取一个int
    • @param offset
    • @return
      */
      private int readInt3(int offset) {
      mbb.position(offset);
      return mbb.getInt() & 0x00FFFFFF;
      }

    /**

    • 从内存映射文件的当前位置开始的3个字节读取一个int
    • @return
      */
      private int readInt3() {
      return mbb.getInt() & 0x00FFFFFF;
      }

    /**

    • 根据IP得到国家名
    • @param ip ip的字节数组形式
    • @return 国家名字符串
      */
      public String getCountry(byte[] ip) {
      // 检查ip地址文件是否正常
      if (ipFile == null) return “”;
      // 保存ip，转换ip字节数组为字符串形式
      String ipStr = IPProcessUtils.getIpStringFromBytes(ip);
      // 先检查cache中是否已经包含有这个ip的结果，没有再搜索文件
      if (ipCache.containsKey(ipStr)) {
      IPLocation loc = (IPLocation) ipCache.get(ipStr);
      return loc.country;
      } else {
      IPLocation loc = getIPLocation(ip);
      ipCache.put(ipStr, loc.getCopy());
      return loc.country;
      }
      }

    /**

    • 根据IP得到国家名
    • @param ip IP的字符串形式
    • @return 国家名字符串
      */
      public String getCountry(String ip) {
      return getCountry(IPProcessUtils.getIpByteArrayFromString(ip));
      }

    /**

    • 根据IP得到地区名
    • @param ip ip的字节数组形式
    • @return 地区名字符串
      */
      public String getArea(byte[] ip) {
      // 检查ip地址文件是否正常
      if (ipFile == null) return “”;
      // 保存ip，转换ip字节数组为字符串形式
      String ipStr = IPProcessUtils.getIpStringFromBytes(ip);
      // 先检查cache中是否已经包含有这个ip的结果，没有再搜索文件
      if (ipCache.containsKey(ipStr)) {
      IPLocation loc = (IPLocation) ipCache.get(ipStr);
      return loc.area;
      } else {
      IPLocation loc = getIPLocation(ip);
      ipCache.put(ipStr, loc.getCopy());
      return loc.area;
      }
      }

    /**

    • 根据IP得到地区名
    • @param ip IP的字符串形式
    • @return 地区名字符串
      */
      public String getArea(String ip) {
      return getArea(IPProcessUtils.getIpByteArrayFromString(ip));
      }

    /**

    • 根据ip搜索ip信息文件，得到IPLocation结构，所搜索的ip参数从类成员ip中得到
    • @param ip 要查询的IP
    • @return IPLocation结构
      */
      private IPLocation getIPLocation(byte[] ip) {
      IPLocation info = null;
      long offset = locateIP(ip);
      if (offset != -1) info = getIPLocation(offset);
      if (info == null) {
      info = new IPLocation();
      info.country = “未知国家”;
      info.area = “未知地区”;
      }
      return info;
      }

    /**

    • 从offset位置读取4个字节为一个long，因为java为big-endian格式，所以没办法
    • 用了这么一个函数来做转换
    • @param offset
    • @return 读取的long值，返回-1表示读取文件失败
      */
      private long readLong4(long offset) {
      long ret = 0;
      try {
      ipFile.seek(offset);
      ret |= (ipFile.readByte() & 0xFF);
      ret |= ((ipFile.readByte() << 8) & 0xFF00);
      ret |= ((ipFile.readByte() << 16) & 0xFF0000);
      ret |= ((ipFile.readByte() << 24) & 0xFF000000);
      return ret;
      } catch (IOException e) {
      return -1;
      }
      }

    /**

    • 从offset位置读取3个字节为一个long，因为java为big-endian格式，所以没办法
    • 用了这么一个函数来做转换
    • @param offset
    • @return 读取的long值，返回-1表示读取文件失败
      */
      private long readLong3(long offset) {
      long ret = 0;
      try {
      ipFile.seek(offset);
      ipFile.readFully(b3);
      ret |= (b3[0] & 0xFF);
      ret |= ((b3[1] << 8) & 0xFF00);
      ret |= ((b3[2] << 16) & 0xFF0000);
      return ret;
      } catch (IOException e) {
      return -1;
      }
      }

    /**

    • 从当前位置读取3个字节转换成long
    • @return
      */
      private long readLong3() {
      long ret = 0;
      try {
      ipFile.readFully(b3);
      ret |= (b3[0] & 0xFF);
      ret |= ((b3[1] << 8) & 0xFF00);
      ret |= ((b3[2] << 16) & 0xFF0000);
      return ret;
      } catch (IOException e) {
      return -1;
      }
      }

    /**

    • 从offset位置读取四个字节的ip地址放入ip数组中，读取后的ip为big-endian格式，但是
    • 文件中是little-endian形式，将会进行转换
    • @param offset
    • @param ip
      */
      private void readIP(long offset, byte[] ip) {
      try {
      ipFile.seek(offset);
      ipFile.readFully(ip);
      byte temp = ip[0];
      ip[0] = ip[3];
      ip[3] = temp;
      temp = ip[1];
      ip[1] = ip[2];
      ip[2] = temp;
      } catch (IOException e) {
      logger.error(e.getMessage());
      }
      }

    /**

    • 从offset位置读取四个字节的ip地址放入ip数组中，读取后的ip为big-endian格式，但是
    • 文件中是little-endian形式，将会进行转换
    • @param offset
    • @param ip
      */
      private void readIP(int offset, byte[] ip) {
      mbb.position(offset);
      mbb.get(ip);
      byte temp = ip[0];
      ip[0] = ip[3];
      ip[3] = temp;
      temp = ip[1];
      ip[1] = ip[2];
      ip[2] = temp;
      }

    /**

    • 把类成员ip和beginIp比较，注意这个beginIp是big-endian的
    • @param ip 要查询的IP
    • @param beginIp 和被查询IP相比较的IP
    • @return 相等返回0，ip大于beginIp则返回1，小于返回-1。
      */
      private int compareIP(byte[] ip, byte[] beginIp) {
      for (int i = 0; i < 4; i++) {
      int r = compareByte(ip[i], beginIp[i]);
      if (r != 0) return r;
      }
      return 0;
      }

    /**

    • 把两个byte当作无符号数进行比较
    • @param b1
    • @param b2
    • @return 若b1大于b2则返回1，相等返回0，小于返回-1
      */
      private int compareByte(byte b1, byte b2) {
      if ((b1 & 0xFF) > (b2 & 0xFF)) // 比较是否大于
      return 1;
      else if ((b1 ^ b2) == 0)// 判断是否相等
      return 0;
      else return -1;
      }

    /**

    • 这个方法将根据ip的内容，定位到包含这个ip国家地区的记录处，返回一个绝对偏移
    • 方法使用二分法查找。
    • @param ip 要查询的IP
    • @return 如果找到了，返回结束IP的偏移，如果没有找到，返回-1
      */
      private long locateIP(byte[] ip) {
      long m = 0;
      int r;
      // 比较第一个ip项
      readIP(ipBegin, b4);
      r = compareIP(ip, b4);
      if (r == 0)
      return ipBegin;
      else if (r < 0) return -1;
      // 开始二分搜索
      for (long i = ipBegin, j = ipEnd; i < j;) {
      m = getMiddleOffset(i, j);
      readIP(m, b4);
      r = compareIP(ip, b4);
      // log.debug(IPProcessUtils.getIpStringFromBytes(b));
      if (r > 0)
      i = m;
      else if (r < 0) {
      if (m == j) {
      j -= IP_RECORD_LENGTH;
      m = j;
      } else j = m;
      } else return readLong3(m + 4);
      }
      // 如果循环结束了，那么i和j必定是相等的，这个记录为最可能的记录，但是并非
      // 肯定就是，还要检查一下，如果是，就返回结束地址区的绝对偏移
      m = readLong3(m + 4);
      readIP(m, b4);
      r = compareIP(ip, b4);
      if (r <= 0)
      return m;
      else return -1;
      }

    /**

    • 得到begin偏移和end偏移中间位置记录的偏移
    • @param begin
    • @param end
    • @return
      */
      private long getMiddleOffset(long begin, long end) {
      long records = (end - begin) / IP_RECORD_LENGTH;
      records >>= 1;
      if (records == 0) records = 1;
      return begin + records * IP_RECORD_LENGTH;
      }

    /**

    • 给定一个ip国家地区记录的偏移，返回一个IPLocation结构
    • @param offset
    • @return
      */
      private IPLocation getIPLocation(long offset) {
      try {
      // 跳过4字节ip
      ipFile.seek(offset + 4);
      // 读取第一个字节判断是否标志字节
      byte b = ipFile.readByte();
      if (b == AREA_FOLLOWED) {
      // 读取国家偏移
      long countryOffset = readLong3();
      // 跳转至偏移处
      ipFile.seek(countryOffset);
      // 再检查一次标志字节，因为这个时候这个地方仍然可能是个重定向
      b = ipFile.readByte();
      if (b == NO_AREA) {
      loc.country = readString(readLong3());
      ipFile.seek(countryOffset + 4);
      } else loc.country = readString(countryOffset);
      // 读取地区标志
      loc.area = readArea(ipFile.getFilePointer());
      } else if (b == NO_AREA) {
      loc.country = readString(readLong3());
      loc.area = readArea(offset + 8);
      } else {
      loc.country = readString(ipFile.getFilePointer() - 1);
      loc.area = readArea(ipFile.getFilePointer());
      }
      return loc;
      } catch (IOException e) {
      return null;
      }
      }

    /**

    • @param offset
    • @return
      */
      private IPLocation getIPLocation(int offset) {
      // 跳过4字节ip
      mbb.position(offset + 4);
      // 读取第一个字节判断是否标志字节
      byte b = mbb.get();
      if (b == AREA_FOLLOWED) {
      // 读取国家偏移
      int countryOffset = readInt3();
      // 跳转至偏移处
      mbb.position(countryOffset);
      // 再检查一次标志字节，因为这个时候这个地方仍然可能是个重定向
      b = mbb.get();
      if (b == NO_AREA) {
      loc.country = readString(readInt3());
      mbb.position(countryOffset + 4);
      } else loc.country = readString(countryOffset);
      // 读取地区标志
      loc.area = readArea(mbb.position());
      } else if (b == NO_AREA) {
      loc.country = readString(readInt3());
      loc.area = readArea(offset + 8);
      } else {
      loc.country = readString(mbb.position() - 1);
      loc.area = readArea(mbb.position());
      }
      return loc;
      }

    /**

    • 从offset偏移开始解析后面的字节，读出一个地区名
    • @param offset
    • @return 地区名字符串
    • @throws IOException
      */
      private String readArea(long offset) throws IOException {
      ipFile.seek(offset);
      byte b = ipFile.readByte();
      if (b == 0x01 || b == 0x02) {
      long areaOffset = readLong3(offset + 1);
      if (areaOffset == 0)
      return “未知地区”;
      else return readString(areaOffset);
      } else return readString(offset);
      }

    /**

    • @param offset
    • @return
      */
      private String readArea(int offset) {
      mbb.position(offset);
      byte b = mbb.get();
      if (b == 0x01 || b == 0x02) {
      int areaOffset = readInt3();
      if (areaOffset == 0)
      return “未知地区”;
      else return readString(areaOffset);
      } else return readString(offset);
      }

    /**

    • 从offset偏移处读取一个以0结束的字符串
    • @param offset
    • @return 读取的字符串，出错返回空字符串
      */
      private String readString(long offset) {
      try {
      ipFile.seek(offset);
      int i;
      for (i = 0, buf[i] = ipFile.readByte(); buf[i] != 0; buf[++i] = ipFile
      .readByte())
      ;
      if (i != 0) return IPProcessUtils.getString(buf, 0, i, “GBK”);
      } catch (IOException e) {
      logger.error(e.getMessage());
      }
      return “”;
      }

    /**

    • 从内存映射文件的offset位置得到一个0结尾字符串
    • @param offset
    • @return
      */
      private String readString(int offset) {
      try {
      mbb.position(offset);
      int i;
      for (i = 0, buf[i] = mbb.get(); buf[i] != 0; buf[++i] = mbb.get())
      ;
      if (i != 0) return IPProcessUtils.getString(buf, 0, i, “GBK”);
      } catch (IllegalArgumentException e) {
      logger.error(e.getMessage());
      }
      return “”;
      }

    public String getAddress(String ip) {
    String country = getCountry(ip).equals(" CZ88.NET") ? “”
    : getCountry(ip);
    String area = getArea(ip).equals(" CZ88.NET") ? “” : getArea(ip);
    String address = country;
    return address.trim();
    }

    public boolean isFileRead() {
    return fileRead;
    }

    public void setFileRead(boolean fileRead) {
    this.fileRead = fileRead;
    }
    }
    IPProcessUtils.java

package com.jk.utils.readDat;

import java.io.UnsupportedEncodingException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**

  • @author
    /
    public class IPProcessUtils {
    private static Logger logger = LoggerFactory.getLogger(IPProcessUtils.class);
    /    *

    • 从ip的字符串形式得到字节数组形式
    • @param ip 字符串形式的ip
    • @return 字节数组形式的ip
      */
      public static byte[] getIpByteArrayFromString(String ip) {
      byte[] ret = new byte[4];
      java.util.StringTokenizer st = new java.util.StringTokenizer(ip, “.”);
      try {
      ret[0] = (byte)(Integer.parseInt(st.nextToken()) & 0xFF);
      ret[1] = (byte)(Integer.parseInt(st.nextToken()) & 0xFF);
      ret[2] = (byte)(Integer.parseInt(st.nextToken()) & 0xFF);
      ret[3] = (byte)(Integer.parseInt(st.nextToken()) & 0xFF);
      } catch (Exception e) {
      logger.error(e.getMessage());
      }
      return ret;
      }

    public static void main(String args[]){

// byte[] a=getIpByteArrayFromString(“219.143.33.50”);
// for(int i=0;i< a.length;i++)
// System.out.println(a[i]);
// System.out.println(getIpStringFromBytes(a));
// Map<String,String > ipmap = CtwapUtil.CTWAP_IP_MAP;
// for (String key : ipmap.keySet()) {
//
// System.out.println(“key= “+ key + " and value= " + map.get(key));
//
// }
long t1=System.currentTimeMillis();
String ip=“192.168.1.1”;
IPSeeker ipSeeker=IPSeeker.getInstance();
String zore=ipSeeker.getAddress(ip);
long t2=System.currentTimeMillis();
System.out.println(”>>”+zore);
}
/**
* 对原始字符串进行编码转换，如果失败，返回原始的字符串
* @param s 原始字符串
* @param srcEncoding 源编码方式
* @param destEncoding 目标编码方式
* @return 转换编码后的字符串，失败返回原始字符串
*/
public static String getString(String s, String srcEncoding, String destEncoding) {
try {
return new String(s.getBytes(srcEncoding), destEncoding);
} catch (UnsupportedEncodingException e) {
return s;
}
}

/**
 * 根据某种编码方式将字节数组转换成字符串
 * @param b 字节数组
 * @param encoding 编码方式
 * @return 如果encoding不支持，返回一个缺省编码的字符串
 */
public static String getString(byte[] b, String encoding) {
    try {
        return new String(b, encoding);
    } catch (UnsupportedEncodingException e) {
        return new String(b);
    }
}

/**
 * 根据某种编码方式将字节数组转换成字符串
 * @param b 字节数组
 * @param offset 要转换的起始位置
 * @param len 要转换的长度
 * @param encoding 编码方式
 * @return 如果encoding不支持，返回一个缺省编码的字符串
 */
public static String getString(byte[] b, int offset, int len, String encoding) {
    try {
        return new String(b, offset, len, encoding);
    } catch (UnsupportedEncodingException e) {
        return new String(b, offset, len);
    }
}

/**
 * @param ip ip的字节数组形式
 * @return 字符串形式的ip
 */
public static String getIpStringFromBytes(byte[] ip) {
    StringBuffer sb = new StringBuffer();
    sb.append(ip[0] & 0xFF);
    sb.append('.');       
    sb.append(ip[1] & 0xFF);
    sb.append('.');       
    sb.append(ip[2] & 0xFF);
    sb.append('.');       
    sb.append(ip[3] & 0xFF);
    return sb.toString();
}

}

哭都不让哭！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java基于QQWry.Dat实现IP位置定位，项目可直接运行
06-06
java基于QQWry.Dat实现IP位置定位,项目提供相应的算法可直接运行。。希望能够帮助大家。。
java读取纯真IP数据库QQwry.dat的源代码--获取ip所在地区
04-04
NULL 博文链接：https://songjianyong.iteye.com/blog/1500127
java ip 查询定位 QQwry.dat
qingchen191的专栏
02-16 642
转发： http://lgl669.iteye.com/blog/414115
最新IP地址数据库精简版，仅保留省份和城市（QQWry.dat版）
05-23
根据纯真IP数据库2012.5.15最新数据库简化仅保留省份和城市。本文件是QQWry.dat版，还有MYSQL版
java读取qqwry.dat实现IP地域查询
09-21
qqwry.dat是一个包含全球IP地址及其对应地理位置信息的数据文件，由著名的IP查询库——QuanWuRy（超级IP库）提供。在Java中，我们可以利用文件流和二进制读取方式来解析这个数据文件，从而快速地将IP地址转化为实际...
IP定位QQwry.dat文件
12-25
总之，QQwry.dat文件是一个高效、便捷的IP定位工具，它的存在极大地简化了地理位置信息的获取过程，为各种应用场景提供了便利。通过合理利用和开发，我们可以从中获得更多的价值。如果你是一名IT从业者，了解并掌握...
java qqWry.dat多个IP同时查询代码
02-08
总结来说，"java qqWry.dat多个IP同时查询代码"是一个利用Java编程实现的IP查询项目，通过并发处理多个IP地址，利用qqWry.dat数据库进行高效查询。这涉及到了文件读取、二进制解析、并发编程等多个Java核心技术，...
如何借助qqwry.dat文件实现查询指定IP所属地的共能
06-30
qqwry.dat是由腾讯公司维护的一个IP数据库，它包含了全球范围内的IP地址与对应地理位置的映射关系，更新频繁，准确性较高。 首先，了解qqwry.dat文件的结构。这是一个二进制文件，其内部存储了IP地址和地理位置信息...
php获取用户ip并跳转指定城市
07-23 213
以上就是PHP获取IP地址、PHP根据IP地址判断城市以及PHP根据IP地址实现城市切换或跳转的详细介绍了，事实上，像PHP中通过IP地址自动切换城市就是这个方法的典型应用。举一反三，我们通过这种方法，也可以实现屏蔽指定IP地址或城市的用户访问，自己研究一下吧，也挺简单的：）接下来，我们在上面的ipcity目录下新建一个ipaddress.php文件，直接复制以下代码进去即可，重要的地方也作了相应注释。//提取出来的数据转换成长整形，如果数据是负数则加上2的32次幂。//获取IP地址索引开始和结束位置。
java实现qqWry.datIP查询源码
10-23
java读取qqWry.dat实现多IP同时查询源码，另外包含一个qqwry.dat文件实现查询指定IP所属地的共能源码。两份代码仅供参考。
java开发基于百度API，淘宝API和腾讯IP库(qqwry.dat)，通过IP获取区域城市位置，经纬度获取城市地址，城市地址获取经纬度等信息实例
02-10
该demo有多个JAVA实例，分别是基于：百度API，淘宝API和腾讯提供的IP库(qqwry.dat)，开发的一个简单直接可以使用的web应用程序，通过Eclipse导入即可在Main方法中测试； 1.百度API已经提供测试ak密钥，实例中有：a.通过经纬度获取地址，b.通过地址获取经纬度，c.通过外网IP获取地址详细信息等；(具体信息有：经纬度，ISP，区域编码，区域名称，城市名称，省份名称) 2.淘宝API测试示例是通过IP获取地址，同上，但是没有经纬度的； 3.腾讯qqwry.dat是支持离线通过IP获取地址，是没有经纬度的； 4.提供方法ascii转中文； 备注，如果百度ak不能用了请在百度申请http://lbsyun.baidu.com/apiconsole/key，由衷的希望对大家有帮助提高开发效率，如有其他需求可以留言。
leke-qqwry:Java qqwry.dat IP 地址库查找
05-06
leke-qqwry leke-qqwry 是一个纯真IP地址库(qqwry.dat)数据读取类库。 使用方式： ClassPathResource datFile = new ClassPathResource("data/qqwry.dat"); IPv4LocatorFactoryBean fb = new IPv4LocatorFactoryBean(); fb.setDatFile(datFile); fb.afterPropertiesSet(); IPv4Locator locator = fb.getObject(); IPv4Loc loc = locator.locate("39.184.174.243"); System.out.println(loc); // 浙江省 移动
java读取纯真IP数据库QQwry.dat的源代码
热门推荐
swallow的专栏
05-16 1万+
java读取纯真IP数据库QQwry.dat的源代码,要运行此程序必须有到网上下载QQwry.da，由于太大，我这里就不提供了。一、IPEntry.java/** *//** ** 一条IP范围记录，不仅包括国家和区域，也包括起始IP和结束IP *  *  * @author swallow */public class IPEntry ...{    public String begi
JAVA解析纯真IP地址库,得到运营商，省市信息
juanqiao7497的博客
08-07 6658
通过QQIP地址数据库（纯真版）官网http://www.cz88.net/fox/ipdat.shtml，下载软件，然后安装完成后，在安装目录会自动生成QQWry.Dat，如下图 （如果不需要解析省市等复杂信息，只需要得到运营商等简单信息可以参考https://github.com/jarod/qqwry-java） 将QQWry.Dat放在maven项目的resource目录...
QQWRY Java
最新发布
gitblog_00056的博客
03-17 414
QQWRY Java qqwry-javaA java library to read QQWry IP database. (纯真IP地址数据库)项目地址:https://gitcode.com/gh_mirrors/qq/qqwry-java 是一个开源的 Java 库，用于查询 IP 地址归属地信息。 简介 IP 地址归属地查询是一种常见的需求，在网络安全、数据分析等领域都有着广泛的应用。...
java qqwry.dat_QQWry.dat文件格式
weixin_33158453的博客
02-21 190
想不到QQwry还在用,这是俺两年前设计的,这个格式该被淘汰了.为什么这么说呢,因为它采用的是索引+二分查找来减小内存占用和提高查找速度的.由于采用二分查找,所以IP数据要被分为最小的片,假设有A,B两条数据,B数据完全覆盖A数据,那么转换为QQwry 后两条数据就变成了三条.如果原始数据非常有条理,就可以避免这个现象,不过这是不可能的,几万条数据会越来越乱,所以QQwry的尺寸会迅速增加,之所以...
qqwry.dat java 乱码_纯真IP数据库TQQWry的ASP读取源码(UTF-8编码)
weixin_42319396的博客
02-13 239
以下是引用片段：' ============================================' 返回IP地区信息' ============================================Function Look_Ip(IP)Dim Wry, IPType, QQWryVersion, IpCounter' 设置类对象Set Wry = New TQQWry' 开...
Java实现QQwry.dat IP定位技术
QQwry.dat是由QQ公司维护的一个包含全球IP地址与对应国家、地区信息的数据库，它定期更新以保持数据的准确性。 首先，我们来看`IPEntry.java`类，这是用于存储IP范围记录的类。每个IPEntry对象包含四个属性：起始IP...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值