IP地址归属地查询完整版

 

package controller;

import java.util.Scanner;

import manager.DataProcessManager;

public class SystemController {
	@SuppressWarnings("resource")
	public static void main(String[] args) {
		// 接收用户输入
		Scanner scanner = new Scanner(System.in);
		while (true) {
			System.out.println("请输入IP地址 : ");
			String ip = scanner.nextLine();
			// 查询
			long startTime = System.currentTimeMillis();
			String location = DataProcessManager.getLocation(ip);
			long endTime = System.currentTimeMillis();
			System.out.println("总耗时 : " + (endTime - startTime) + "  "
					+ location);
		}
	}

}

package manager;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import pojo.IPAndLocationPojo;
import utli.FileOperatorUtil;
import utli.IPUtil;
import utli.RegexUtil;
import utli.SerDeUtil;
import utli.StaticValue;
/**
 * 程序核心业务类
 *
 */
public class DataProcessManager {
	private static IPAndLocationPojo[] ipAndLocationPojoArray = null;
	static {
		// 保存数据对象
		List<IPAndLocationPojo> ipAndLocationPojos = null;
		// 判断是否有序列化的文件
		File file = new File(StaticValue.serdeObiFilePath);
		if (file.exists()) {
			// TODO
			long startTime = System.currentTimeMillis();
			// 如果存在 就反序列化
			try {
				Object obj = SerDeUtil.getObj(StaticValue.serdeObiFilePath,
						StaticValue.cacheByteArrayLength);
				ipAndLocationPojoArray = (IPAndLocationPojo[]) obj;
			} catch (ClassNotFoundException | IOException e) {
				e.printStackTrace();
			}
			long endTime = System.currentTimeMillis();
			System.out.println("反序列化,耗时 : " + (endTime - startTime));
		} else {
			// 不存在 就读取数据 并且结构化 排序 然后 进行序列化
			try {
				// 获取数据
				ipAndLocationPojos = DataProcessManager.getPojoList(
						StaticValue.ipLibrayPath, StaticValue.encoding);
				// 转数组并排序
				// TODO
				long startTime = System.currentTimeMillis();
				ipAndLocationPojoArray = DataProcessManager
						.convertListToArraySort(ipAndLocationPojos);
				// 序列化
				SerDeUtil.saveObj(ipAndLocationPojoArray,
						StaticValue.serdeObiFilePath,
						StaticValue.cacheByteArrayLength);
				long endTime = System.currentTimeMillis();
				System.out.println("转数组并排序序列化,耗时 : " + (endTime - startTime));

			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 对外提供的接口,入参是IP,出参是归属地
	 * 
	 * @param ip
	 * @return
	 */
	public static String getLocation(String ip) {
		// 校验IP
		if (!RegexUtil.isValidIP(ip)) {
			return "请输入正确的IP地址";
		}
		// 二分法查找
		int index = DataProcessManager.binaraySeach(ipAndLocationPojoArray, ip);
		// 判断是否找到
		if (index == -1) {
			return null;
		} else {
			return ipAndLocationPojoArray[index].getLocation();
		}
	}

	/**
	 * 二分法查找,入参是IP和数组,出参是对应的索引,找不到返回-1
	 * 
	 * @param ipAndLocationPojoArray
	 * @param targetIP
	 * @return
	 * @throws IOException
	 */
	private static int binaraySeach(IPAndLocationPojo[] ipAndLocationPojoArray,
			String targetIP) {
		// 把IP转换为long
		long targetIPLong = IPUtil.ipToLong(targetIP);
		int startIndex = 0;
		int endIndex = ipAndLocationPojoArray.length - 1;
		int m = (startIndex + endIndex) / 2;

		/**
		 * 如果 小于 起始IP 找前面
		 * 
		 * 如果 大于 结束IP 找后面
		 * 
		 * 如果 大于等于起始IP且 小于等于 结束IP 则说明找到了
		 */
		while (startIndex <= endIndex) {
			if (targetIPLong >= ipAndLocationPojoArray[m].getStartIPLong()
					&& targetIPLong <= ipAndLocationPojoArray[m].getEndIPLong()) {
				return m;
			}
			if (targetIPLong < ipAndLocationPojoArray[m].getStartIPLong()) {
				endIndex = m - 1;
			} else {
				startIndex = m + 1;
			}
			m = (startIndex + endIndex) / 2;
		}
		return -1;
	}

	/**
	 * 把集合转换为数组并排序
	 * 
	 * @param ipAndLocationPojos
	 * @return
	 */
	private static IPAndLocationPojo[] convertListToArraySort(
			List<IPAndLocationPojo> ipAndLocationPojos) {

		// 创建数组
		IPAndLocationPojo[] ipAndLocationPojoArray = new IPAndLocationPojo[ipAndLocationPojos
				.size()];
		// 转换为数组
		ipAndLocationPojos.toArray(ipAndLocationPojoArray);
		// 排序
		Arrays.sort(ipAndLocationPojoArray);
		return ipAndLocationPojoArray;
	}

	/**
	 * 结构化数据集合
	 * 
	 * @param filePath
	 * @param encoding
	 * @return
	 * @throws IOException
	 */
	private static List<IPAndLocationPojo> getPojoList(String filePath,
			String encoding) throws IOException {

		// 保存数据对象
		List<IPAndLocationPojo> ipAndLocationPojos = new ArrayList<IPAndLocationPojo>();
		// TODO
		long startTime = System.currentTimeMillis();
		List<String> lineList = FileOperatorUtil
				.getLineList(filePath, encoding);
		long endTime = System.currentTimeMillis();
		System.out.println("读取数据,耗时 : " + (endTime - startTime));
		startTime = System.currentTimeMillis();
		for (String string : lineList) {
			// 判断是否是空行
			if (string == null || string.trim().equals("")) {
				continue;
			}
			// 分割为数组
			String[] columnArray = string.split("	");
			// 获取起始IP
			String startIP = columnArray[0];
			// 获取结束IP
			String endIP = columnArray[1];
			// 获取归属地
			String location = columnArray[2];
			// 封装到对象中
			IPAndLocationPojo ipAndLocationPojo = new IPAndLocationPojo(
					startIP, endIP, location);
			// 添加到集合中
			ipAndLocationPojos.add(ipAndLocationPojo);
		}
		endTime = System.currentTimeMillis();
		System.out.println("结构化数据,耗时 : " + (endTime - startTime));
		return ipAndLocationPojos;
	}

}

package pojo;
import java.io.Serializable;
import utli.IPUtil;
public class IPAndLocationPojo {
	private static final long serialVersionUID = 1L;
	// 衍生字段,用于保存IP对应的long值
	private long startIPLong;
	private long endIPLong;
	/**
	 * 起始IP
	 */
	private transient String startIP;
	/**
	 * 结束IP
	 */
	private transient String endIP;
	/**
	 * 归属地
	 */
	private String location;

	public int compareTo(IPAndLocationPojo o) {
		long status = this.startIPLong - o.startIPLong;
		// 不能强制转换 , 如果两个值相差 2147483647的话,转换为int之后 得到负数
		// return (int) (this.startIPLong - o.startIPLong);
		return status > 0 ? 1 : 0;
	}

	public String getStartIP() {
		return startIP;
	}

	public long getStartIPLong() {
		return startIPLong;
	}

	public void setStartIPLong(long startIPLong) {
		this.startIPLong = startIPLong;
	}

	public long getEndIPLong() {
		return endIPLong;
	}

	public void setEndIPLong(long endIPLong) {
		this.endIPLong = endIPLong;
	}

	public void setStartIP(String startIP) {
		this.startIP = startIP;
	}

	public String getEndIP() {
		return endIP;
	}

	public void setEndIP(String endIP) {
		this.endIP = endIP;
	}

	public String getLocation() {
		return location;
	}

	public void setLocation(String location) {
		this.location = location;
	}

	public IPAndLocationPojo(String startIP, String endIP, String location) {
		super();
		this.startIP = startIP;
		this.endIP = endIP;
		this.location = location;
		// 对长整型赋值
		this.startIPLong = IPUtil.ipToLong(startIP);
		this.endIPLong = IPUtil.ipToLong(endIP);
	}

	public IPAndLocationPojo() {
		super();
	}

	@Override
	public String toString() {
		return "IPAndLocationPojo [startIP=" + startIP + ", endIP=" + endIP
				+ ", location=" + location + "]";
	}

}

 

package utli;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.util.ArrayList;
import java.util.List;

public class FileOperatorUtil {
	/**
	 * 读取文件并返回list集合
	 * 
	 * @param filePath
	 *            文件路径
	 * @param encoding
	 *            字符编码
	 * @return
	 * @throws IOException
	 */
	public static List<String> getLineList(String filePath, String encoding)
			throws IOException {
		// 2 节点流对接文件
		FileInputStream fis = new FileInputStream(filePath);
		// 3 转换为字符流并指定字符编码
		Reader reader = new InputStreamReader(fis, encoding);
		// 4 缓冲流提高效率
		BufferedReader br = new BufferedReader(reader);
		// 5 读取
		String line = null;
		// 保存读取的数据
		List<String> lineList = new ArrayList<String>();
		while ((line = br.readLine()) != null) {
			// 添加到集合中
			lineList.add(line);
		}
		// 6 关闭
		br.close();
		return lineList;
	}

}

package utli;

public class IPUtil {
	public static void main(String[] args) {
		String ip = "126.56.78.59";
		long ipLong = ipToLong(ip);
		System.out.println(ipLong);
		System.out.println(longToIP(ipLong));
	}

	/**
	 * 将127.0.0.1形式的IP地址转换成十进制整数，这里没有进行任何错误处理
	 * 通过左移位操作（<<）给每一段的数字加权，第一段的权为2的24次方，第二段的权为2的16次方，第三段的权为2的8次方，最后一段的权为1
	 */
	public static long ipToLong(String ipaddress) {
		long[] ip = new long[4];
		// 先找到IP地址字符串中.的位置
		int position1 = ipaddress.indexOf(".");
		int position2 = ipaddress.indexOf(".", position1 + 1);
		int position3 = ipaddress.indexOf(".", position2 + 1);
		// 将每个.之间的字符串转换成整型
		ip[0] = Long.parseLong(ipaddress.substring(0, position1));
		ip[1] = Long.parseLong(ipaddress.substring(position1 + 1, position2));
		ip[2] = Long.parseLong(ipaddress.substring(position2 + 1, position3));
		ip[3] = Long.parseLong(ipaddress.substring(position3 + 1));
		return (ip[0] << 24) + (ip[1] << 16) + (ip[2] << 8) + ip[3];
	}

	/**
	 * 将十进制整数形式转换成127.0.0.1形式的ip地址 将整数值进行右移位操作（>>>），右移24位，右移时高位补0，得到的数字即为第一段IP。
	 * 通过与操作符（&）将整数值的高8位设为0，再右移16位，得到的数字即为第二段IP。
	 * 通过与操作符吧整数值的高16位设为0，再右移8位，得到的数字即为第三段IP。 通过与操作符吧整数值的高24位设为0，得到的数字即为第四段IP。
	 */
	public static String longToIP(long ipaddress) {
		StringBuffer sb = new StringBuffer("");
		// 直接右移24位
		sb.append(String.valueOf((ipaddress >>> 24)));
		sb.append(".");
		// 将高8位置0，然后右移16位
		sb.append(String.valueOf((ipaddress & 0x00FFFFFF) >>> 16));
		sb.append(".");
		// 将高16位置0，然后右移8位
		sb.append(String.valueOf((ipaddress & 0x0000FFFF) >>> 8));
		sb.append(".");
		// 将高24位置0
		sb.append(String.valueOf((ipaddress & 0x000000FF)));
		return sb.toString();
	}

}

package utli;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 正则表达式工具类
 *
 *
 */
public class RegexUtil {
	/**
	 * 校验IP
	 * 
	 */
	public static boolean isValidIP(String input){
		String regex="(?=(\\b|\\D))(((\\d{1,2})|(1\\d{1,2})|(2[0-4]\\d)|(25[0-5]))\\.){3}((\\d{1,2})|(1\\d{1,2})|(2[0-4]\\d)|(25[0-5]))(?=(\\b|\\D))";
		return isValid(regex,input);
	
	}
	/**
	 * 格式校验 全词匹配
	 * 
	 */
	public static boolean isValid(String regex,String input){
		//创建引擎对象
		Pattern pattern=Pattern.compile(regex);
		//创建匹配器
		Matcher matcher=pattern.matcher(input);
		return matcher.matches();
	}

}

package utli;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * 序列化相关工具类
 * 
 *
 */
public class SerDeUtil {
	/**
	 * 序列化
	 */
	public static void saveObj(Object obj,String filePath,int cacheByteArrayLength)throws IOException{
		//1 序列化
		FileOutputStream fos=new FileOutputStream(filePath);
		//字节数组流
		ByteArrayOutputStream baos=new ByteArrayOutputStream(cacheByteArrayLength);
		//数据写出到字节数组中
		oos.writeObject(obj);
		//转换为字节数组
		byte[]byteArray=baos.toByteArray();
		oos.flush();
		oos.close();
		
		fos.write(byteArray);
		fos.close();
	}
	/**
	 * 反序列化
	 */

	public static Object getObj(String filePath,int cacheByteArrayLength)throws IOException,ClassNotFoundException{
		//2 反序列化
		FileInputStream fis=new FileInputStream(filePath);
		byte[]byteArray=new byte[cacheByteArrayLength];
		//数据读取到字节数组中
		fis.read(byteArray);
		fis.close();
		//字节数组缓冲流
		ByteArrayInputStream bais=new ByteArrayInputStream(byteArray);
		ObjectInputStream ois=new ObjectInputStream(bais);
		Object obj=ois.readObject();
		ois.close();
		return obj;
		
		
	}
}

package utli;
/**
 * 集中的静态变量
 *
 *
 */
public class StaticValue {
	//序列化之后的文件名
	public static String serdeObiFilePath="ipLibObj.data";
	//地址库文件路径
	public static String ipLibrayPath="ip_location_relation.txt";
	//字符编码
	public static String encoding="UTF-8";
	//序列化文件大小
	public static int cacheByteArrayLength=25*1024*1024;

}