文档章节

java纯真IP解析

天空之风
 天空之风
发布于 2014/04/16 12:50
字数 3013
阅读 1872
收藏 20
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.io.UnsupportedEncodingException;
import java.nio.MappedByteBuffer;
import java.util.Hashtable;
import java.util.StringTokenizer;

/**
 * <pre>
 * 用来读取QQwry.dat文件,以根据ip获得好友位置,QQwry.dat的格式是
 * 一. 文件头,共8字节
 *    1. 第一个起始IP的绝对偏移, 4字节
 *     2. 最后一个起始IP的绝对偏移, 4字节
 * 二. &quot;结束地址/国家/区域&quot;记录区
 *     四字节ip地址后跟的每一条记录分成两个部分
 *     1. 国家记录
 *     2. 地区记录
 *     但是地区记录是不一定有的。而且国家记录和地区记录都有两种形式
 *     1. 以0结束的字符串
 *     2. 4个字节,一个字节可能为0x1或0x2
 *   a. 为0x1时,表示在绝对偏移后还跟着一个区域的记录,注意是绝对偏移之后,而不是这四个字节之后
 *        b. 为0x2时,表示在绝对偏移后没有区域记录
 *        不管为0x1还是0x2,后三个字节都是实际国家名的文件内绝对偏移
 *   如果是地区记录,0x1和0x2的含义不明,但是如果出现这两个字节,也肯定是跟着3个字节偏移,如果不是
 *        则为0结尾字符串
 * 三. &quot;起始地址/结束地址偏移&quot;记录区
 *     1. 每条记录7字节,按照起始地址从小到大排列
 *        a. 起始IP地址,4字节
 *        b. 结束ip地址的绝对偏移,3字节
 * 
 * 注意,这个文件里的ip地址和所有的偏移量均采用little-endian格式,而java是采用
 * big-endian格式的,要注意转换
 * </pre>
 *
 */
public class IPSeeker {
 /**
  * <pre>
  * 用来封装ip相关信息,目前只有两个字段,ip所在的国家和地区
  * </pre>
  * 
  
  */
 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 final Hashtable ipCache;
 // 随机文件访问类
 private RandomAccessFile ipFile;
 // 内存映射文件
 private MappedByteBuffer mbb;
 // 单一模式实例
 private static IPSeeker instance = new IPSeeker();
 // 起始地区的开始和结束的绝对偏移
 private long ipBegin, ipEnd;
 // 为提高效率而采用的临时变量
 private final IPLocation loc;
// private final byte[] buf;//不需要了
 private final byte[] b4;
 private final byte[] b3;
 /**
  * 私有构造函数
  */
 private IPSeeker() {
  ipCache = new Hashtable();
  loc = new IPLocation();
//  buf = new byte[100];//不需要了,这里初始化不好!
  b4 = new byte[4];
  b3 = new byte[3];
  try {
   System.out.println(IP_FILE);
   ipFile = new RandomAccessFile(IP_FILE, "r");
  } catch (FileNotFoundException e) {
   System.out.println(IPSeeker.class.getResource("QQWry.dat").toString());
   System.out.println(IP_FILE);
   System.out.println("IP地址信息文件没有找到,IP显示功能将无法使用");
   ipFile = null;
  }
  // 如果打开文件成功,读取文件头信息
  if (ipFile != null) {
   try {
    ipBegin = readLong4(0);
    ipEnd = readLong4(4);
    if (ipBegin == -1 || ipEnd == -1) {
     ipFile.close();
     ipFile = null;
    }
   } catch (IOException e) {
    System.out.println("IP地址信息文件格式有错误,IP显示功能将无法使用");
    ipFile = null;
   }
  }
 }
 /**
  * @return 单一实例
  */
 public static IPSeeker getInstance() {
  return instance;
 }
 

 /**
  * 从内存映射文件的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,转换ip字节数组为字符串形式
  String ipStr = 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;
  }
 }
     private  byte[] getIpByteArrayFromString(String ip) {  
          byte[] ret = new byte[4];  
          StringTokenizer st = new 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) {  
          //  LogFactory.log("从ip的字符串形式得到字节数组形式报错", Level.ERROR, e);  
          }  
          return ret;  
    }  
      /** 
       * @param ip ip的字节数组形式 
       * @return 字符串形式的ip 
       */  
     private  String getIpStringFromBytes(byte[] ip) {  
       StringBuilder sb = new StringBuilder();
       sb.delete(0, sb.length());  
          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();  
      } 
   /**
    * 根据某种编码方式将字节数组转换成字符串
    * 
    * @param b
    *            字节数组
    * @param offset
    *            要转换的起始位置
    * @param len
    *            要转换的长度
    * @param encoding
    *            编码方式
    * @return 如果encoding不支持,返回一个缺省编码的字符串
    */
     private  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);
    }
   }
 
 /**
  * 根据IP得到国家名
  * 
  * @param ip
  *            IP的字符串形式
  * @return 国家名字符串
  */
 public String getCountry(String ip) {
  return getCountry(getIpByteArrayFromString(ip));
 }
 /**
  * 根据IP得到地区名
  * 
  * @param ip
  *            ip的字节数组形式
  * @return 地区名字符串
  */
 public String getArea(byte[] ip) {
  // 检查ip地址文件是否正常
  if (ipFile == null)
   return "错误的IP数据库文件";
  // 保存ip,转换ip字节数组为字符串形式
  String ipStr = 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(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) {
   System.out.println(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(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());
   //上面的写法读取数据如果超过100个字节就会报数组越界异常
   int i = 0;
   byte[] buf = new byte[256];
   while ((buf[i] = ipFile.readByte()) != 0) {
       ++ i;
       if (i >= buf.length) {
           byte[] tmp = new byte[i + 100];
           System.arraycopy(buf, 0, tmp, 0, i);
           buf = tmp;
       }
   }
   /////////
   if (i != 0)
    return getString(buf, 0, i, "GBK");
  } catch (IOException e) {
   System.out.println(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());
   int i = 0;
   byte[] buf = new byte[256];
   while ((buf[i] = mbb.get()) != 0) {
       ++ i;
       if (i >= buf.length) {
           byte[] tmp = new byte[i + 100];
           System.arraycopy(buf, 0, tmp, 0, i);
           buf = tmp;
       }
   }
   if (i != 0)
    return getString(buf, 0, i, "GBK");
  } catch (IllegalArgumentException e) {
   System.out.println(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 + " " + area;
  return address.trim();
 }
 
 
 }
@Test

 public void test5(){
  IPSeeker ip=IPSeeker.getInstance();
  System.out.println(ip.getCountry("114.114.114.114"));
}

   java网络获取地址

public String getCity(HttpServletRequest request){

  IPSeeker ips=IPSeeker.getInstance();
  String ip = request.getHeader("x-forwarded-for");

        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {

            ip = request.getHeader("Proxy-Client-IP");

        }

        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {

            ip = request.getHeader("WL-Proxy-Client-IP");

        }

        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {

            ip = request.getRemoteAddr();

        }

  return ips.getCountry(ip) ;

 }

© 著作权归作者所有

天空之风
粉丝 1
博文 6
码字总数 5130
作品 0
渝北
程序员
私信 提问
Java解析归属地,以前用纯真库,现在需要兼容ipv6

之前项目用纯真的ip库,然后写的Java代码查询纯真库中相应ip的归属地,现在项目需要支持ipv6的ip地址,所以归属地查询就是问题,首先 纯真的ipv6版本的数据库去哪里下载? 其次 查询该ipv6的...

bluysky
2013/08/15
482
0
利用Hadoop 根据IP地址进行地域统计

最近一直在做地域统计的功能,用户下载app的日志中记录了IP,老大要根据这个IP做个地域统计,看看哪些地方的用户喜欢下载哪些应用。最初是用Java跑纯真IP地址数据库,然后对日志进行统计,不...

王二铁
2012/03/23
942
15
关于java的DNS解析IP缓存问题

java对DNS解析IP进行缓存,默认缓存超时时间为-1(在重启JVM前永久缓存), 在第一次访问某域名后将会缓存解析到的IP地址,之后直接从缓存里获得所需的信息(如IP地址),而无需再访问DNS服务...

Sub
2013/08/09
798
0
python +ip2region IP库地址文件实现秒级查询1万不同ip归属地址

一、服务器环境介绍: 服务器硬件:4核4g内存 服务器系统:centos6.9 x86_64位最小化安装 二、环境安装 参考地址:https://github.com/lionsoul2014/ip2region 直接下载包到服务器上的/root...

wjw555
2018/07/09
0
0
关于 Java 使用代理时的 DNS 解析问题!!!

Java 程序在使用 Socks5 代理访问国外网页的时候,经常会碰到同一个网页在浏览器上通过代理可以正常访问。但是在 Java 程序中通过同一个代理却无法访问的情况。 经过数个小时的研究发现这种情...

红薯
2016/05/19
911
1

没有更多内容

加载失败,请刷新页面

加载更多

分布式协调服务zookeeper

ps.本文为《从Paxos到Zookeeper 分布式一致性原理与实践》笔记之一 ZooKeeper ZooKeeper曾是Apache Hadoop的一个子项目,是一个典型的分布式数据一致性的解决方案,分布式应用程序可以基于它...

ls_cherish
今天
4
0
redis 学习2

网站 启动 服务端 启动redis 服务端 在redis 安装目录下 src 里面 ./redis-server & 可以指定 配置文件或者端口 客户端 在 redis 的安装目录里面的 src 里面 ./redis-cli 可以指定 指定 连接...

之渊
昨天
2
0
Spring boot 静态资源访问

0. 两个配置 spring.mvc.static-path-patternspring.resources.static-locations 1. application中需要先行的两个配置项 1.1 spring.mvc.static-path-pattern 这个配置项是告诉springboo......

moon888
昨天
4
0
hash slot(虚拟桶)

在分布式集群中,如何保证相同请求落到相同的机器上,并且后面的集群机器可以尽可能的均分请求,并且当扩容或down机的情况下能对原有集群影响最小。 round robin算法:是把数据mod后直接映射...

李朝强
昨天
4
0
Kafka 原理和实战

本文首发于 vivo互联网技术 微信公众号 https://mp.weixin.qq.com/s/bV8AhqAjQp4a_iXRfobkCQ 作者简介:郑志彬,毕业于华南理工大学计算机科学与技术(双语班)。先后从事过电子商务、开放平...

vivo互联网技术
昨天
24
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部