JAVA 实现IP离线定位

qq_37799512
已于 2024-08-23 14:57:36 修改
阅读量211
点赞数 3
文章标签：服务器运维 java
于 2024-08-23 14:20:09 首次发布
本文链接：https://blog.csdn.net/qq_37799512/article/details/141464815
版权
纯真IP离线库
java 实现
public class IPSeeker {
// 一些固定常量，比如记录长度等等
private static final int IP_RECORD_LENGTH = 7;
private static final byte REDIRECT_MODE_1 = 0x01;
private static final byte REDIRECT_MODE_2 = 0x02;
// resource 路径
private static final String INSTALL_DIR = "static/qqwry.dat";
private static volatile IPSeeker instance = null;
// 用来做为cache，查询一个ip时首先查看cache，以减少不必要的重复查找
// 随机文件访问类
private RandomAccessFile ipFile;
// 内存映射文件
private MappedByteBuffer mbb;
// 起始地区的开始和结束的绝对偏移
private long ipBegin, ipEnd;
// 为提高效率而采用的临时变量
private IPLocation loc;
private byte[] buf;
private byte[] b4;
private byte[] b3;
private RedisCache redisCache;
private IxxService ixxService;

public IPSeeker() {
	redisCache = SpringUtils.getBean(RedisCache.class);
	ixxService= SpringUtils.getBean(IBxzGeoZoneService.class);
	//初始化
	load();
}

//单例
public static IPSeeker getInstance() {
	synchronized (IPSeeker.class) {
        if (instance == null || instance.ipFile == null) {
            synchronized (IPSeeker.class) {
                instance = new IPSeeker();
            }
        }
    }
    return instance;
}

/**
 *  初始化
 */
public void load() {
    loc = new IPLocation();
    buf = new byte[100];
    b4 = new byte[4];
    b3 = new byte[3];
    File file = null;
    InputStream inputStream = null;
	try {
		ClassPathResource classPathResource = new ClassPathResource(INSTALL_DIR);
		inputStream = classPathResource.getInputStream();
		Path tempPath = Files.createTempFile("temp", ".dat");
		file = tempPath.toFile();
		IOUtils.copy(inputStream, file);
		ipFile = new RandomAccessFile(file, "r");
	} catch (Exception e) {
		log.info("【离线IP库】 - 文件不存在", e);
	} finally {
		if (file != null) {
			file.delete();
		}
		if (inputStream != null) {
			try {
				inputStream.close();
			} catch (IOException ignored) {
			}
		}
	}
	// 如果打开文件成功，读取文件头信息
	if (ipFile != null) {
		try {
			ipBegin = readLong4(0);
			ipEnd = readLong4(4);
			if (ipBegin == -1 || ipEnd == -1) {
				ipFile.close();
				ipFile = null;
			}
		}catch (IOException e) {
			log.info("【离线IP库】 - 文件格式有错误", e);
			ipFile = null;
		}
	}
	log.info("【离线IP库】 - 加载完成");
}





/**
 * 从内存映射文件的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 null;
	// 保存ip，转换ip字节数组为字符串形式
	String ipStr = IpUtils.getIpStringFromBytes(ip);
	// 先检查cache中是否已经包含有这个ip的结果，没有再搜索文件
	String country = redisCache.getCacheObject(Constants.IP_CACHE + ipStr);
	if (StringUtils.isEmpty(country)) {
		IPLocation ipLoc = getIPLocation(ip);
		String countryCn = ipLoc.getCountry();
		log.info("【IP】 - {}  - 【解析后】 -> {}", ipStr, countryCn);
		Pattern regexPattern = Pattern.compile("(.*?)(自治区|省|行政区|市|区)");
		Matcher matcher = regexPattern.matcher(countryCn);
		LinkedList<String> zoneCnList = new LinkedList<>();
		if (matcher.find()) {
			zoneCnList.add(matcher.group());
		}
		String area = zoneCnList.getLast();
		//缓存
		String zoneCode = redisCache.getCacheObject(Constants.IP_CACHE_COUNTRY + area);
		if (StringUtils.isEmpty(zoneCode)) {
			Xx geoZone = ixxService.selectGeoZoneByZoneName(area);
			if (Objects.isNull(geoZone)) return null;
			redisCache.setCacheObject(Constants.IP_CACHE_COUNTRY + area, geoZone );
		}
		redisCache.setCacheObject(Constants.IP_CACHE + ipStr, zoneCode);
		return zoneCode;
	} else {
		log.info("【IP】 - {}  - 【解析后】 -> {}", ipStr, country);
	}
	return country;
}

/**
 * 根据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 = getZoneNameLocation(offset);
	if (info == null) {
		info = new IPLocation();
		info.setCountry(Message.unknown_country);
		info.setArea(Message.unknown_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 读取的long值，返回-1表示读取文件失败
 */
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) {
		log.info("格式转换异常", e);
	}
}

/**
 * 从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(Utils.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;
}

/**
 * 从内存映射文件的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 IpUtils.getString(buf, 0, i, "GBK");
	} catch (IllegalArgumentException e) {
		log.info("", e);
	}
	return "";
}


/**
 * 给定一个ip国家地区记录的偏移，返回一个IPLocation结构
 *
 * @param offset 国家记录的起始偏移
 * @return IPLocation对象
 */
private IPLocation getIPLocation(long offset) {
	try {
		// 跳过4字节ip
		ipFile.seek(offset + 4);
		// 读取第一个字节判断是否标志字节
		byte b = ipFile.readByte();
		if (b == REDIRECT_MODE_1) {
			// 读取国家偏移
			long countryOffset = readLong3();
			ipFile.seek(countryOffset);
			b = ipFile.readByte();
			if (b == REDIRECT_MODE_2) {
				loc.setCountry(readString(readLong3()));
				ipFile.seek(countryOffset + 4);
			} else
				loc.setCountry(readString(countryOffset));
			// 读取地区标志
			loc.setArea(readArea(ipFile.getFilePointer()));
		} else if (b == REDIRECT_MODE_2) {
			loc.setCountry(readString(readLong3()));
			loc.setArea(readArea(offset + 8));
		} else {
			loc.setCountry(readString(ipFile.getFilePointer() - 1));
			loc.setArea(readArea(ipFile.getFilePointer()));
		}
		return loc;
	} catch(IOException e) {
		return null;
	}
}
IP地址位置数据由纯真CZ88提供支持