Java获取IP地址及对应的归属地

已于 2024-04-08 16:43:47 修改
阅读量4.6k 收藏 49
点赞数 27
文章标签： java spring 网络协议 ip
于 2024-01-11 14:45:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42555014/article/details/135336509
版权

目录

前言

一、获取访问的IP地址

二、通过IP地址获取对应的归属地

2.1 Ip2region

2.1.1 高达 99.9 % 的查询准确率

2.1.2 Ip2region V2.0 特性

2.1.3 多语言以及查询客户端的支持

2.2 Ip2region xdb Java 查询客户端实现

2.2.1 引入 Maven 仓库

2.2.2 ip2region.xdb 文件，放到工程resources目录下

2.2.3 实现方式

2.2.3.1 基于文件查询

2.2.3.2 缓存VectorIndex索引

2.2.3.3 缓存整个 xdb 数据

2.2.3.4 通过第三方API查询（在线查询）

2.2.3.5 最优方案

前言

        细心的朋友们可能已经发现了，先在抖音、知乎、快手、小红书等这些平台已经上线了“网络用户显示 IP 的功能”，境外用户显示的是国家，国内的用户显示的省份，而且此项显示无法关闭，归属地强制显示。

作为一个努力搬砖的码农，我们肯定要来看一下这个功能是如何实现的，今天这篇文章，就来讲述一下这个功能是怎么实现的。

一、获取访问的IP地址

HttpServletRequest 获取 IP

首先我们来看一下，在 Java 中，是如何获取到 IP 属地的，主要有以下两步：

  • 通过 HttpServletRequest 对象，获取用户的 【IP】 地址

  • 通过 IP 地址，获取对应的【省份、城市】

我这里写一个工具类用于获取 IP 地址，因为用户的每次 Request 请求都会携带请求的 IP 地址放到请求头中，所以我们可以通过截取请求中的 IP 来获取 IP 地址，代码如下：

package com.test.java.util;

import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpHeaders;
import org.springframework.http.server.reactive.ServerHttpRequest;

import javax.servlet.http.HttpServletRequest;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.util.Objects;

/**
 * IP地址Util
 */
@Slf4j
public class IpAddressUtil {

    /**
     * 获取请求的 IP 地址
     */
    public static String getIpAddress(HttpServletRequest request) {
        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();
            if ("127.0.0.1".equals(ip)) {
                // 根据网卡取本机配置的 IP
                InetAddress inet = null;
                try {
                    inet = InetAddress.getLocalHost();
                } catch (Exception e) {
                    e.printStackTrace();
                    log.error("获取IP地址异常，{}", e.getMessage());
                }
                if (inet != null) {
                    ip = inet.getHostAddress();
                }
            }
        }
        // 多个代理的情况，第一个IP为客户端真实IP,多个IP按照','分割
        if (ip != null && ip.length() > 15) {
            if (ip.indexOf(",") > 0) {
                ip = ip.substring(0, ip.indexOf(","));
            }
        }
        // 本机访问
        if ("localhost".equalsIgnoreCase(ip) || "127.0.0.1".equalsIgnoreCase(ip) || "0:0:0:0:0:0:0:1".equalsIgnoreCase(ip)) {
            // 根据网卡取本机配置的IP
            InetAddress inet;
            try {
                inet = InetAddress.getLocalHost();
                ip = inet.getHostAddress();
            } catch (Exception e) {
                e.printStackTrace();
                log.error("获取本机IP地址异常，{}", e.getMessage());
            }
        }
        // 如果查找不到 IP,可以返回 127.0.0.1，可以做一定的处理，但是这里不考虑
        // if (ip == null) {
        //     return "127.0.0.1";
        // }
        return ip;
    }

    /**
     * 获取IP地址
     */
    public static String getIpAddress(ServerHttpRequest request) {
        HttpHeaders headers = request.getHeaders();
        String ipAddress = headers.getFirst("X-Forwarded-For");
        if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
            ipAddress = headers.getFirst("Proxy-Client-IP");
        }
        if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
            ipAddress = headers.getFirst("WL-Proxy-Client-IP");
        }
        if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
            ipAddress = Objects.requireNonNull(request.getRemoteAddress()).getAddress().getHostAddress();
            if ("127.0.0.1".equals(ipAddress) || "0:0:0:0:0:0:0:1".equals(ipAddress)) {
                // 根据网卡取本机配置的IP
                try {
                    InetAddress inet = InetAddress.getLocalHost();
                    ipAddress = inet.getHostAddress();
                } catch (Exception e) {
                    log.error("获取IP地址异常,{}", e.getMessage());
                }
            }
        }

        // 对于通过多个代理的情况，第一个IP为客户端真实IP，多个IP按照','分割
        if (ipAddress != null && ipAddress.indexOf(",") > 0) {
            ipAddress = ipAddress.split(",")[0];
        }
        return ipAddress;
    }

    /**
     * 获取mac地址
     */
    public static String getMacIpAddress() {
        try {
            InetAddress inetAddress = InetAddress.getLocalHost();
            byte[] macAddressBytes = NetworkInterface.getByInetAddress(inetAddress).getHardwareAddress();
            // 将mac地址拼装成String
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < macAddressBytes.length; i++) {
                if (i != 0) {
                    sb.append("-");
                }
                // mac[i] & 0xFF 是为了把byte转化为正整数
                String s = Integer.toHexString(macAddressBytes[i] & 0xFF);
                sb.append(s.length() == 1 ? 0 + s : s);
            }
            return sb.toString().trim().toUpperCase();
        } catch (Exception e) {
            log.error("Mac获取IP地址异常,{}", e.getMessage());
        }
        return "";
    }

}

这里出现了三个名词：

  • X-Forwarded-For：一个 HTTP 扩展头部，主要是为了让 Web 服务器获取访问用户的真实 IP 地址。每个 IP 地址，每个值通过逗号+空格分开，最左边是最原始客户端的 IP 地址，中间如果有多层代理，每⼀层代理会将连接它的客户端 IP 追加在 X-Forwarded-For 右边

  • X-Real-IP：一般只记录真实发出请求的客户端IP

  • Proxy-Client-IP：这个一般是经过 Apache http 服务器的请求才会有，用 Apache http 做代理时一般会加上 Proxy-Client-IP 请求头

  • WL-Proxy-Client-IP：也是通过 Apache http 服务器，在 weblogic 插件加上的头

二、通过IP地址获取对应的归属地

通过第三方地址库 Ip2region，获取IP归属地。

2.1 Ip2region

Ip2region 是一个 Gthub 的开源项目，即 Ip2region 开源项目。

github地址：https://github.com/lionsoul2014/ip2region

这个开源库目前已经更新到了 V2 的版本，现在的它是一个强大的离线IP地址定位库和IP定位数据管理框架，其达到了微秒级别的查询效率，还提供了众多主流编程语言的 xdb 数据生成和查询客户端实现，可以说是非常得好用👍👍👍👍

2.1.1 高达 99.9 % 的查询准确率

数据聚合了一些知名 ip 到地名查询提供商的数据，这些是他们官方的准确率，经测试着实比经典的纯真 IP 定位准确一些。

ip2region 的数据聚合自以下服务商的开放 API 或者数据(升级程序每秒请求次数 2 到 4 次)，比例如下：

80%, 淘宝 IP 地址库, ip.taobao.com/
≈10%, GeoIP, geoip.com/
≈2%, 纯真 IP 库, www.cz88.net/

2.1.2 Ip2region V2.0 特性

  • IP 数据管理框架

xdb 支持亿级别的 IP 数据段行数，默认的 region 信息都固定了格式：国家|区域|省份|城市|ISP，缺省的地域信息默认是0。

只有中国的数据精确到了城市，其他国家有部分数据只能定位到国家，后前的选项全部是 0，已经包含了全部你能查到的大大小小的国家

生成的数据库文件 ip2region.db 只有几 MB，最小的版本只有 1.5MB，随着数据的详细度增加数据库的大小也慢慢增大，目前还没超过 8MB。

region 信息支持完全自定义，例如：你可以在 region 中追加特定业务需求的数据，例如：GPS信息/国际统一地域信息编码/邮编等。也就是你完全可以使用 ip2region 来管理你自己的 IP 定位数据。

  • 数据去重和压缩

xdb 格式生成程序会自动去重和压缩部分数据，默认的全部 IP 数据，生成的 ip2region.xdb 数据库是 11MiB，随着数据的详细度增加数据库的大小也慢慢增大。

  • 极速查询响应

即使是完全基于 xdb 文件的查询，单次查询响应时间在十微秒级别，可通过如下两种方式开启内存加速查询：

  1. vIndex 索引缓存：使用固定的 512KiB 的内存空间缓存 vector index 数据，减少一次 IO 磁盘操作，保持平均查询效率稳定在10-20微秒之间

  2. xdb 整个文件缓存：将整个 xdb 文件全部加载到内存，内存占用等同于 xdb 文件大小，无磁盘 IO 操作，保持微秒级别的查询效率。

  • 内置的三种查询算法

全部的查询客户端单次查询都在 0.x 毫秒级别，内置了三种查询算法：

  1. memory 算法：整个数据库全部载入内存，单次查询都在0.1x毫秒内，C语言的客户端单次查询在0.00x毫秒级别。

  2. binary 算法：基于二分查找，基于ip2region.db文件，不需要载入内存，单次查询在0.x毫秒级别。

  3. b-tree 算法：基于btree算法，基于ip2region.db文件，不需要载入内存，单词查询在0.x毫秒级别，比binary算法更快。

2.1.3 多语言以及查询客户端的支持

已经有的客户端：Java、C#、php、C、Python、Node.js、PHP 拓展（PHP 5 和 PHP 7）等，主要如下：

binding描述开发状态binary查询耗时b-tree查询祥时memory查询耗时
CANSC C binding已完成0.0x毫秒0.0x毫秒0.00x毫秒
C#C# binding已完成0.x毫秒0.x毫秒0.1x毫秒
Golanggolang binding已完成0.x毫秒0.x毫秒0.1x毫秒
Javajava binding已完成0.x毫秒0.x毫秒0.1x毫秒
Lualua实现 binding已完成0.x毫秒0.x毫秒0.x毫秒
Lua_clua的c扩展已完成0.0x毫秒0.0x毫秒0.00x毫秒
nginxnginx的c扩展已完成0.0x毫秒0.0x毫秒0.00x毫秒
nodejsnodejs已完成0.x毫秒0.x毫秒0.1x毫秒
phpphp实现 binding已完成0.x毫秒0.1x毫秒0.1x毫秒
php5_ extphp5的c扩展已完成0.0x毫秒0.0x毫秒0.00x毫秒
php7_ extphp7的c扩展已完成0.0x毫秒0.0x毫秒0.00x毫秒
pythonpython bindng已完成0.x毫秒0.x毫秒0.x毫秒
rustrust binding已完成0.x毫秒0.x毫秒0.x毫秒

2.2 Ip2region xdb Java 查询客户端实现

这里简单展示一下 Java 的实现，这里使用开发中常用的 Maven 实现的方式：

2.2.1 引入 Maven 仓库

<!-- IP地址转归属地 -->
<dependency>
   <groupId>org.lionsoul</groupId>
   <artifactId>ip2region</artifactId>
   <version>2.6.4</version>
</dependency>

2.2.2 ip2region.xdb 文件，放到工程resources目录下

这个xdb文件我放到网盘里，大伙可以直接下载，或者直接去GitHub上访问下载。

百度网盘地址：ip2region.xdb

提取码：4399

2.2.3 实现方式

2.2.3.1 基于文件查询
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.lionsoul.ip2region.xdb.Searcher;

import java.util.concurrent.TimeUnit;

/**
 * IP地址Util
 */
@Slf4j
public class IpAddressUtil {

    // ip2region.xdb 文件地址常量（本地xdb文件路径）
    public static String XDB_PATH = "D:\\IDEA2022.2.3\\workspace\\java\\src\\main\\resources\\ip\\ip2region.xdb";
    
    /**
     * 完全基于ip2region.xdb文件，对用户ip地址进行转换
     * 注：并发调用时，每个线程需创建一个独立的searcher对象 单独使用。
     */
    public static String getIpPossessionByFile(String ip) {
        if (StringUtils.isNotEmpty(ip)) {
            try {
                // 1、创建 searcher 对象
                Searcher searcher = Searcher.newWithFileOnly(XDB_PATH);
                // 2、查询
                long sTime = System.nanoTime();
                String region = searcher.search(ip);
                long cost = TimeUnit.NANOSECONDS.toMicros(System.nanoTime() - sTime);
                region = region.replace("|0", "");
                log.info("{地区: {}, IO操作数: {}, 耗时: {} μs}", region, searcher.getIOCount(), cost);
                return region;
            } catch (Exception e) {
                log.error("获取IP地址异常：{} ", e.getMessage());
                throw new RuntimeException("获取IP地址异常");
            }
        }
        return "未知";
    }

}
2.2.3.2 缓存VectorIndex索引

我们可以提前从 xdb 文件中加载出来 VectorIndex 数据，然后全局缓存，每次创建 Searcher 对象的时候使用全局的 VectorIndex 缓存可以减少一次固定的 IO 操作，从而加速查询，减少 IO 压力。

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.lionsoul.ip2region.xdb.Searcher;

import java.util.concurrent.TimeUnit;

/**
 * IP地址Util
 */
@Slf4j
public class IpAddressUtil {

    // ip2region.xdb 文件地址常量（本地xdb文件路径）
    public static String XDB_PATH = "D:\\IDEA2022.2.3\\workspace\\java\\src\\main\\resources\\ip\\ip2region.xdb";

    /**
     * 缓存 VectorIndex 索引，对用户ip地址进行转换
     * 注：每个线程需要单独创建一个独立的 Searcher 对象，但是都共享全局变量 vIndex 缓存。
     */
    public static String getCityInfoByVectorIndex(String ip) {
        if (StringUtils.isNotEmpty(ip)) {
            try {
                // 1、从 XDB_PATH 中预先加载 VectorIndex 缓存，并且作为全局变量，后续反复使用。
                byte[] vIndex = Searcher.loadVectorIndexFromFile(XDB_PATH);
                // 2、使用全局的 vIndex 创建带 VectorIndex 缓存的查询对象。
                Searcher searcher = Searcher.newWithVectorIndex(XDB_PATH, vIndex);
                // 3、查询
                long sTime = System.nanoTime();
                String region = searcher.search(ip);
                long cost = TimeUnit.NANOSECONDS.toMicros(System.nanoTime() - sTime);
                region = region.replace("|0", "");
                log.info("{地区: {}, IO操作数: {}, 耗时: {} μs}", region, searcher.getIOCount(), cost);
                return region;
            } catch (Exception e) {
                log.error("获取IP地址异常：{} ", e.getMessage());
                throw new RuntimeException("获取IP地址异常");
            }
        }
        return "未知";
    }

}
2.2.3.3 缓存整个 xdb 数据

我们也可以预先加载整个 ip2region.xdb 的数据到内存，然后基于这个数据创建查询对象来实现完全基于文件的查询，类似之前的 memory search。

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.lionsoul.ip2region.xdb.Searcher;

import java.util.concurrent.TimeUnit;

/**
 * IP地址Util
 */
@Slf4j
public class IpAddressUtil {

    // ip2region.xdb 文件地址常量
    public static String XDB_PATH = "D:\\java\\src\\main\\resources\\ip\\ip2region.xdb";

    /**
     * 缓存整个 xdb 数据，对用户ip地址进行转换
     * 注：并发使用时，用整个 xdb 数据缓存创建的查询对象可以安全的用于并发，也就是你可以把这个 searcher 对象做成全局对象去跨线程访问。
     */
    public static String getCityInfoByMemorySearch(String ip) {
        if (StringUtils.isNotEmpty(ip)) {
            try {
                // 1、从 XDB_PATH 加载整个 xdb 到内存。
                byte[] cBuff = Searcher.loadContentFromFile(XDB_PATH);
                // 2、使用上述的 cBuff 创建一个完全基于内存的查询对象。
                Searcher searcher = Searcher.newWithBuffer(cBuff);
                // 3、查询
                long sTime = System.nanoTime();
                String region = searcher.search(ip);
                long cost = TimeUnit.NANOSECONDS.toMicros(System.nanoTime() - sTime);
                region = region.replace("|0", "");
                log.info("{地区: {}, IO操作数: {}, 耗时: {} μs}", region, searcher.getIOCount(), cost);
                return region;
            } catch (Exception e) {
                log.error("获取IP地址异常：{} ", e.getMessage());
                throw new RuntimeException("获取IP地址异常");
            }
        }
        return "未知";
    }

}
2.2.3.4 通过第三方API查询（在线查询）

前面介绍的3种方法都是离线查询，该方法主要通过第三方提供的官网或API接口去实现在线查询的功能，但有个弊端就是特别依赖对方的服务器，一旦对方的服务器宕机就无法访问了。具体实现效果跟之前介绍的离线查询方法是一样的。

import com.google.gson.Gson;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;

/**
 * IP地址Util
 */
@Slf4j
public class IpAddressUtil {

    /**
     * 在线查询IP归属地
     */
    public static String getIpAddressByOnline(String ip) {
        try {
            //1、创建 URLConnction
            URL url = new URL("http://ip-api.com/json/" + ip + "?lang=zh-CN");

            //2、设置connection的属性
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");
            connection.setConnectTimeout(20000);
            connection.setReadTimeout(20000);
            connection.setRequestProperty("content-type", "application/json; charset=utf-8");

            //3.连接
            connection.connect();

            //4.获取内容
            InputStream inputStream = connection.getInputStream();

            BufferedReader br = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8));
            String line;
            StringBuilder sb = new StringBuilder();
            while ((line = br.readLine()) != null) {
                sb.append(line);
            }
            br.close();
            //System.out.println(sb);

            String str = sb.toString();
            if (StringUtils.isNotEmpty(str)) {
                // string转map
                Gson gson = new Gson();
                Map<String, Object> map = new HashMap<>();
                map = gson.fromJson(str, map.getClass());
                String country = (String) map.get("country");
                String city = (String) map.get("city");
                String regionName = (String) map.get("regionName");
                System.out.println("国家：" + country);
                System.out.println("城市：" + city);
                System.out.println("地区：" + regionName);
                return country + "|" + city + "|" + regionName;
            }
        } catch (Exception e) {
            log.error("在线查询IP地址异常，{}", e.getMessage());
            throw new RuntimeException(e.getMessage());
        }
        return null;
    }

}
2.2.3.5 最优方案

其实我推荐可以将方法结合使用。先采用离线查询，如果发现地址为null的话，则调用在线查询方法。这样在一定的程度上能够保证数据的完整性。完整的工具类如下：

import com.google.gson.Gson;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.lionsoul.ip2region.xdb.Searcher;

import javax.servlet.http.HttpServletRequest;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * IP地址Util
 */
@Slf4j
public class IpAddressUtil {

    // ip2region.xdb 文件地址常量（本地xdb文件路径）
    public static String XDB_PATH = "D:\\IDEA2022.2.3\\workspace\\java\\src\\main\\resources\\ip\\ip2region.xdb";

    /**
     * 获取IP地址：
     */
    public static String getIpAddress(HttpServletRequest request) {
        String ipAddress = null;
        try {
            ipAddress = request.getHeader("X-Forwarded-For");
            if (ipAddress != null && ipAddress.length() != 0 && !"unknown".equalsIgnoreCase(ipAddress)) {
                // 多次反向代理后会有多个ip值，第一个ip才是真实ip
                if (ipAddress.contains(",")) {
                    ipAddress = ipAddress.split(",")[0];
                }
            }
            if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
                ipAddress = request.getHeader("Proxy-Client-IP");
            }
            if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
                ipAddress = request.getHeader("WL-Proxy-Client-IP");
            }
            if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
                ipAddress = request.getHeader("HTTP_CLIENT_IP");
            }
            if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
                ipAddress = request.getRemoteAddr();
            }
        } catch (Exception e) {
            log.error("获取IP地址异常,{}", e.getMessage());
        }
        return ipAddress;
    }

    /**
     * 获取mac地址
     */
    public static String getMacIpAddress() {
        try {
            InetAddress inetAddress = InetAddress.getLocalHost();
            byte[] macAddressBytes = NetworkInterface.getByInetAddress(inetAddress).getHardwareAddress();
            // 将mac地址拼装成String
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < macAddressBytes.length; i++) {
                if (i != 0) {
                    sb.append("-");
                }
                // mac[i] & 0xFF 是为了把byte转化为正整数
                String s = Integer.toHexString(macAddressBytes[i] & 0xFF);
                sb.append(s.length() == 1 ? 0 + s : s);
            }
            return sb.toString().trim().toUpperCase();
        } catch (Exception e) {
            log.error("Mac获取IP地址异常,{}", e.getMessage());
        }
        return "";
    }

    /**
     * 方法一：完全基于ip2region.xdb文件，对用户ip地址进行转换
     * 注：并发调用时，每个线程需创建一个独立的searcher对象 单独使用。
     */
    public static String getIpPossessionByFile(String ip) {
        if (StringUtils.isNotEmpty(ip)) {
            try {
                // 1、创建 searcher 对象
                Searcher searcher = Searcher.newWithFileOnly(XDB_PATH);
                // 2、查询
                long sTime = System.nanoTime();
                String region = searcher.search(ip);
                long cost = TimeUnit.NANOSECONDS.toMicros(System.nanoTime() - sTime);
                region = region.replace("|0", "");
                //log.info("{地区: {}, IO操作数: {}, 耗时: {} μs}", region, searcher.getIOCount(), cost);
                return region;
            } catch (Exception e) {
                log.error("获取IP地址异常：{} ", e.getMessage());
                throw new RuntimeException("获取IP地址异常");
            }
        }
        return "未知";
    }

    /**
     * 方法二：缓存 VectorIndex 索引，对用户ip地址进行转换
     * 注：每个线程需要单独创建一个独立的 Searcher 对象，但是都共享全局变量 vIndex 缓存。
     */
    public static String getCityInfoByVectorIndex(String ip) {
        if (StringUtils.isNotEmpty(ip)) {
            try {
                // 1、从 XDB_PATH 中预先加载 VectorIndex 缓存，并且作为全局变量，后续反复使用。
                byte[] vIndex = Searcher.loadVectorIndexFromFile(XDB_PATH);
                // 2、使用全局的 vIndex 创建带 VectorIndex 缓存的查询对象。
                Searcher searcher = Searcher.newWithVectorIndex(XDB_PATH, vIndex);
                // 3、查询
                long sTime = System.nanoTime();
                String region = searcher.search(ip);
                long cost = TimeUnit.NANOSECONDS.toMicros(System.nanoTime() - sTime);
                region = region.replace("|0", "");
                //log.info("{地区: {}, IO操作数: {}, 耗时: {} μs}", region, searcher.getIOCount(), cost);
                return region;
            } catch (Exception e) {
                log.error("获取IP地址异常：{} ", e.getMessage());
                throw new RuntimeException("获取IP地址异常");
            }
        }
        return "未知";
    }

    /**
     * 方法三：缓存整个 xdb 数据，对用户ip地址进行转换
     * 注：并发使用时，用整个 xdb 数据缓存创建的查询对象可以安全的用于并发，也就是你可以把这个 searcher 对象做成全局对象去跨线程访问。
     */
    public static String getCityInfoByMemorySearch(String ip) {
        if (StringUtils.isNotEmpty(ip)) {
            try {
                // 1、从 XDB_PATH 加载整个 xdb 到内存。
                byte[] cBuff = Searcher.loadContentFromFile(XDB_PATH);
                // 2、使用上述的 cBuff 创建一个完全基于内存的查询对象。
                Searcher searcher = Searcher.newWithBuffer(cBuff);
                // 3、查询
                long sTime = System.nanoTime();
                String region = searcher.search(ip);
                long cost = TimeUnit.NANOSECONDS.toMicros(System.nanoTime() - sTime);
                region = region.replace("|0", "");
                //log.info("{地区: {}, IO操作数: {}, 耗时: {} μs}", region, searcher.getIOCount(), cost);
                return region;
            } catch (Exception e) {
                log.error("获取IP地址异常：{} ", e.getMessage());
                throw new RuntimeException("获取IP地址异常");
            }
        }
        return "未知";
    }

    /**
     * 方法四：在线获取IP地址
     * 注：通过别人或者官网提供的API接口去实现查询的功能，弊端就是特别依赖别人的服务器，一旦服务器宕机就无法访问了。
     */
    public static String getIpAddressByOnline(String ip) {

        try {
            //1、创建 URLConnction
            URL url = new URL("http://ip-api.com/json/" + ip + "?lang=zh-CN");

            //2、设置connection的属性
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");
            connection.setConnectTimeout(20000);
            connection.setReadTimeout(20000);
            connection.setRequestProperty("content-type", "application/json; charset=utf-8");

            //3.连接
            connection.connect();

            //4.获取内容
            InputStream inputStream = connection.getInputStream();

            BufferedReader br = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8));
            String line;
            StringBuilder sb = new StringBuilder();
            while ((line = br.readLine()) != null) {
                sb.append(line);
            }
            br.close();
            //System.out.println(sb);

            String str = sb.toString();
            if (StringUtils.isNotEmpty(str)) {
                // string转map
                Gson gson = new Gson();
                Map<String, Object> map = new HashMap<>();
                map = gson.fromJson(str, map.getClass());
                String country = (String) map.get("country");
                String city = (String) map.get("city");
                String regionName = (String) map.get("regionName");
                //log.info("【国家】{}，【城市】{}，【地区】{}", country, city, regionName);
                return country + "|" + city + "|" + regionName;
            }
        } catch (Exception e) {
            log.error("在线查询IP地址异常，{}", e.getMessage());
            throw new RuntimeException("在线查询IP地址异常");
        }
        return null;
    }

    /**
     * 根据IP地址 获取归属地
     */
    public static String getIpPossession(String ipAddress) {
        if (StringUtils.isNotEmpty(ipAddress)) {
            ipAddress = ipAddress.replace("|", " ");
            String[] cityList = ipAddress.split(" ");
            if (cityList.length > 0) {
                // 国内的显示到具体的省
                if ("中国".equals(cityList[0])) {
                    if (cityList.length > 1) {
                        return cityList[1];
                    }
                }
                // 国外显示到国家
                return cityList[0];
            }
        }
        return "未知";
    }

    public static void main(String[] args) {

        String ip = "183.162.252.0";// 国内IP
        String abroadIp = "48.119.248.100"; // 国外IP

        System.out.println("方法一（国内）：" + getIpPossessionByFile(ip));
        System.out.println("方法二（国内）：" + getCityInfoByVectorIndex(ip));
        System.out.println("方法三（国内）：" + getCityInfoByMemorySearch(ip));
        System.out.println("方法四（国内）：" + getIpAddressByOnline(ip));

        System.out.println("方法一（国外）：" + getIpPossessionByFile(abroadIp));
        System.out.println("方法二（国外）：" + getCityInfoByVectorIndex(abroadIp));
        System.out.println("方法三（国外）：" + getCityInfoByMemorySearch(abroadIp));
        System.out.println("方法四（国外）：" + getIpAddressByOnline(abroadIp));

        //System.out.println("归属地（国内）：" + getIpPossession(getCityInfoByVectorIndex(ip)));
        //System.out.println("归属地（国外）：" + getIpPossession(getCityInfoByVectorIndex(abroadIp)));

    }
}

如果这篇文章对您有所帮助，或者有所启发的话，求一键三连：点赞、评论、收藏➕关注，您的支持是我坚持写作最大的动力。 

Javaの甘乃迪
关注
  • 27
    点赞
  • 踩
  • 49
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
Java根据ip地址获取归属地
m0_73493267的博客
08-30 620
最近，各大平台都新增了评论区显示发言者ip归属地的功能，例如哔哩哔哩，微博，知乎等等。 对这里出现的几个名词解释一下：X-Forwarded-For：一个 HTTP 扩展头部，主要是为了让 Web 服务器获取访问用户的真实 IP 地址。每个 IP 地址，每个值通过逗号+空格分开，最左边是最原始客户端的 IP 地址，中间如果有多层代理，每⼀层代理会将连接它的客户端 IP 追加在 X-Forwarded-For 右边。Proxy-Client-IP：这个一般是经过 Apache http 服务器的请求才会有
Java获取本地IP地址的值
weixin_53275107的博客
12-05 184
import java.net.InetAddress; import java.net.UnknownHostException; public class ipget { //构造方法私有 private ipget(){} //静态修饰 public static String address() throws UnknownHostException { InetAddress addr = InetAddress.getLocalHost();
JAVA通过IP查询详细地址
03-20
NULL 博文链接：https://yafei.iteye.com/blog/758270
通过IP地址查询归属地
06-07
文件提供一份提供IP地址的数据库更新于2017-01； 文件包括一个C语言环境的使用案例和一份java 使用案例
Java获取本机IP地址的方法（内网、公网）
最新发布
m0_52620144的博客
06-17 1337
介绍java获取本机ip，包括WiFi内网IP（排除虚拟机干扰），和对外的公网IP
获取ip归属地
10-24
利用纯真ip数据库获取ip的归属地，完整的代码！纯真ip数据库找度娘搜搜，不会的联系我qq 471461502
Java SpringBoot 根据ip解析ip的所在地区。
L
04-10 800
Java SpringBoot 根据ip解析ip的所在地区
简易java查询IP归属地示例代码
06-02
简易java查询IP归属地示例代码。 面向中国大陆地区的 手机号码、电话号码、IP地址 归属地查询库。 IP地址库来源于 [ip2region](http://git.oschina.net/lionsoul/ip2region)。 手机号码段和电话号码区号信息来源于 [ip138](http://ip138.com/)。 # Maven(pom.xml) ```xml <project> ... <repositories> <repository> <id>zzp-mvn-repo</id> <url>http://10.0.40.218</url> </repository> </repositories> ... <dependencies> <dependency> <groupId>me.zzp</groupId> <artifactId>district</artifactId>
ip2region.xdb
08-01
ip2region v2.0 - 是一个离线IP地址定位库和IP定位数据管理框架。 ip2region 重点在于<b>研究 IP 定位数据的存储设计和各种语言的查询实现</b>，并没有原始 IP 数据的支撑，本项目不保证及时的数据更新
java根据用户请求获取ip地址，并解析省市信息
weixin_43993310的博客
05-25 8479
Ip2region，java,，ip定位
ip2region解析ip获取地区位置
qq_26112725的博客
10-26 1473
【代码】ip2region解析ip获取地区位置。
JAVA根据ip地址获取归属地
weixin_49128211的博客
03-27 2314
​ 如果使用API接口获取，可能会出现服务挂了，或者服务地址不提供服务了等问题。而采用本地地址库就没有这些问题。 本文采用离线IP地址定位库Ip2region，Ip2region是一个离线IP地址定位库，微秒的查询时间获取归属地
java获取客户端IP及IP归属地
10-27
在Java编程中，获取客户端IP地址以及其归属地是一项常见的需求，这主要涉及到网络协议的理解以及第三方库的使用。在Web应用中，服务器通常需要识别来访用户的地理位置信息，以便进行个性化服务、安全控制或者数据...
ip查询归属地收藏 Java 查询IP地址
05-24
根据给定的文件信息，我们可以总结出以下关于“IP查询归属地”以及使用Java进行IP地址查询的关键知识点： ### IP地址基础知识 IP地址是互联网协议(Internet Protocol)地址的简称，用于唯一标识网络上的设备。它由...
IP地址归属地批量网络查询
01-14
标题中的“IP地址归属地批量网络查询”是一个用于获取大量IP地址地理位置信息的程序。它通过网络连接到相应的IP数据库，快速检索出指定IP地址所对应的国家、地区或城市等归属信息。这样的工具在网络安全分析、网站...
ip2region-master_ip2regionjava_ip归属地sqlite_ip地址_IP查询_归属地查询_源码
10-04
IP2Region是一个高效、精确的IP地址查询工具，它允许我们快速获取到IP地址对应的地理位置信息。本文将深入探讨IP2Region的Java实现，以及其与SQLite数据库的结合使用。 1. **IP2Region介绍** IP2Region是一个开源...
根据IP获取地理位置Java（准确率99%）
Mi_RenYu的博客
08-23 1391
在工作中遇到了解析IP地理位置的需求，接下来给大家提供一个简单实用的类库。（我写了两个一个post请求，一个get请求。* 获取ip的国家 post请求。* 获取ip的国家 get请求。1.导入maven依赖。
java根据ip地址获取详细地域信息
热门推荐
hezhoujun的专栏
03-19 3万+
互联网有很多接口可以实现通过ip查询到具体的位置，如下： 通过淘宝IP地址库获取IP位置 1. 请求接口（GET）：http://ip.taobao.com/service/getIpInfo.php?ip=[ip地址字串] 2. 响应信息：（json格式的）国家 、省（自治区或直辖市）、市（县）、运营商 3. 返回数据格式： {"code":0,"data":{"ip":"
java 获取ip归属地
09-16
在 Java 中，我们可以使用第三方库来获取 IP 的归属地信息。其中一个常用的库是 GeoIP2，它基于 MaxMind 的 GeoIP2 数据库。 首先，需要将 GeoIP2 库添加到项目中。可以在 Maven 或 Gradle 构建脚本中添加相应的依赖项。 然后，我们可以使用 GeoIP2 提供的 API 来查询 IP 的归属地。以下是一个示例代码： ```java import com.maxmind.geoip2.DatabaseReader; import com.maxmind.geoip2.model.CityResponse; import com.maxmind.geoip2.record.Country; import java.io.File; import java.io.IOException; import java.net.InetAddress; public class IPUtils { public static String getIPCountry(String ip) { try { File database = new File("GeoIP2-City.mmdb"); DatabaseReader reader = new DatabaseReader.Builder(database).build(); InetAddress ipAddress = InetAddress.getByName(ip); CityResponse response = reader.city(ipAddress); Country country = response.getCountry(); return country.getName(); } catch (IOException e) { e.printStackTrace(); return null; } } public static void main(String[] args) { String ip = "123.456.789.0"; String country = getIPCountry(ip); System.out.println("IP " + ip + " 的归属地是：" + country); } } ``` 在上述示例中，我们通过 `getIPCountry` 方法传入一个 IP 地址，并在 `main` 方法中调用该方法来获取该 IP 的归属地信息。具体的归属地信息包括国家、地区、城市等，可以根据需要进行扩展和处理。 需要注意的是，在运行代码之前，我们需要下载并导入 GeoIP2 数据库文件 `GeoIP2-City.mmdb`，该文件包含了 IP 地址和归属地信息的映射关系。可以从 MaxMind 的官网或其他数据源获取该文件。 这样，我们就可以通过 Java 来获取 IP 的归属地信息了。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Javaの甘乃迪

感谢看客老爷的打赏

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值