离线 IP 定位库 Ip2region 的使用及工具封装详解1、什么是ip2region？ ip2region v2.0

1、什么是ip2region？

ip2region v2.0 - 是一个离线IP地址定位库和IP定位数据管理框架，10微秒级别的查询效率，提供了众多主流编程语言的 xdb 数据生成和查询客户端实现。

2、Ip2region 特性

1、标准化的数据格式

每个 ip 数据段的 region 信息都固定了格式：国家|区域|省份|城市|ISP，只有中国的数据绝大部分精确到了城市，其他国家部分数据只能定位到国家，后前的选项全部是0。

2、数据去重和压缩

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

3、极速查询响应

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

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

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

4、IP 数据管理框架

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

3、基于 `ip2region` 的业务场景应用

1. 内容分发网络（CDN）优化

业务需求：根据用户的 IP 地址，选择最近的 CDN 节点分发资源。
应用场景：

用户访问网站或下载资源时，通过 ip2region 获取用户的地理位置信息（国家、省份、城市）。
根据用户的位置选择对应的 CDN 节点（如北京节点、上海节点、广州节点）分发资源。
提供更低的延迟和更快的加载速度，提升用户体验。

实现逻辑：

获取用户 IP 地址。
使用 ip2region 查询地理位置。
根据地理位置匹配最优的 CDN 节点，并返回资源。

2. 跨境电商的地区定向营销

业务需求：根据用户所在的国家或地区，推荐特定的商品或提供个性化的活动页面。
应用场景：

跨境电商平台根据用户的 IP 地址，确定国家或地区（如中国、美国、欧洲等）。
针对不同地区展示对应的商品价格（如以人民币、美元或欧元结算）。
提供专属的促销活动页面，提升营销效果。

实现逻辑：

获取用户的 IP 地址。
使用 ip2region 获取国家或地区信息。
定制化显示不同地区的商品、价格和营销活动页面。

3. 金融风控与交易拦截

业务需求：根据用户的登录 IP 地理位置，识别异常登录行为，进行风险控制。
应用场景：

用户账户经常性在固定地区登录，如果突然从异地（如国外）登录，需要触发登陆校验或多因子认证。
电商交易时，通过检测用户的 IP 地址和配送地址是否匹配，防止欺诈行为（如盗卡消费）。

实现逻辑：

定期记录用户常用登录 IP 地理位置。
使用 ip2region 查询当前登录 IP 的地理位置。
如果位置异常（如跨国登录），触发风控警告，暂停账户操作或验证用户身份。

4. 网络访问权限控制

业务需求：限制某些地区的访问，或者仅允许特定地区的用户访问服务。
应用场景：

某些服务仅面向特定国家或地区开放（如国内专用服务）。
屏蔽来自某些高风险地区的访问流量，防止恶意攻击或爬虫行为。

实现逻辑：

获取用户的 IP 地址。
使用 ip2region 查询地理位置。
根据规则判断是否允许访问（如禁止某些国家的访问）。

5. 广告投放精准定位

业务需求：根据用户所在的地理位置，投放个性化的广告内容。
应用场景：

广告主可以指定目标地区（如省、市），将广告精准投放给该地区的用户。
提高广告投放的命中率，降低无效投放。

实现逻辑：

获取用户 IP，并通过 ip2region 查询地理位置。
根据地理位置动态加载广告内容。
例如，用户在北京，则展示本地商家的广告；用户在上海，则展示上海的活动信息。

6. 在线教育的地区分布统计与资源优化

业务需求：分析在线教育平台用户的地区分布及学习行为，优化教育资源。
应用场景：

统计各个省份或地区的用户数，用于决定是否扩展当地的线下教学支持。
针对某些地区的用户提供定制化的学习内容（如语言或文化相关课程）。

实现逻辑：

获取用户 IP，通过 ip2region 查询地理位置信息。
按照地区统计用户数量和活跃度。
根据数据动态调整教育资源的分配。

7. 游戏服务器的就近接入

业务需求：根据玩家地理位置，推荐最优的游戏服务器，减少网络延迟。
应用场景：

玩家首次登录游戏时，通过 IP 查询其地理位置。
自动将玩家分配到最近的服务器（例如，东南亚玩家接入新加坡服务器，北美玩家接入洛杉矶服务器）。
提升玩家游戏体验，减少因网络延迟造成的卡顿。

实现逻辑：

获取玩家 IP 地址。
使用 ip2region 获取地理位置。
根据位置选择最近的数据中心或服务器分配。

8. 舆情分析与地域热点追踪

业务需求：根据用户的 IP 分析平台访问分布，识别热点地区行为。
应用场景：

新闻网站或社交平台可以统计某些新闻或话题在不同地区的阅读量或活跃度。
通过分析热点地区用户行为，及时调整内容分发策略。

实现逻辑：

收集用户访问日志，并提取 IP 地址。
使用 ip2region 批量查询用户地理位置。
根据地理位置生成热点地图或访问分布图。

9. 直播平台或在线视频的版权保护

业务需求：根据地区版权限制，控制内容播放区域。
应用场景：

某些影视内容或直播节目只允许在特定国家或地区播放。
屏蔽未授权地区的访问，防止内容侵权。

实现逻辑：

获取用户 IP，通过 ip2region 获取地理位置。
判断用户是否位于授权播放区域。
如果用户不满足条件，则提示“内容不可用”。

10. 物流与配送服务的区域划分

业务需求：根据用户下单的 IP 地址，优化物流的配送区域和服务策略。
应用场景：

根据用户的 IP 地理位置统计订单来源，合理调度物流资源。
针对某些地区用户配置差异化的配送费用（如偏远地区加收运费）。

实现逻辑：

用户下单时获取 IP 地址。
使用 ip2region 查询用户的地理位置。
根据配送区域动态调整物流路线或配送费用。

这些业务场景展示了 ip2region 在 互联网应用、金融风控、广告投放、内容分发 等多个领域的实际应用价值。结合离线查询的高效性和可扩展性，ip2region 可以作为地理位置服务的高效解决方案。

4、代码示例

根据来源ip 判断属于那个国家，然后做过滤

1、依赖引入

<dependency>
   <groupId>org.lionsoul</groupId>
   <artifactId>ip2region</artifactId>
   <version>2.7.0</version>
</dependency>

2、controller控制层代码

@Slf4j
@RequestMapping("/ip2")
@RestController
public class Ip2RegionController {

    private final SearcherIPUtils searcherIPUtils;

    @Autowired
    public Ip2RegionController(SearcherIPUtils searcherIPUtils) {
        this.searcherIPUtils = searcherIPUtils;
    }

    /**
     * 过滤特定国家或省份的请求
     * @param httpServletRequest
     * @param httpServletResponse
     * @param ip ip地址
     * @return
     */
    @GetMapping("/filterByRegion")
    public Map<String, Object> filterByRegion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse,@RequestParam String ip){
        // 从请求中获取实际的客户端IP地址
        ip = IPOfflineUtil.getIpAddr(httpServletRequest);
        log.info("实际的客户端IP地址:{}",ip);
        // 使用默认数据库路径获取缓存的地理位置信息
        String addr = searcherIPUtils.getCachePosition(ip);
        log.info("默认数据库路径获取缓存的地理位置信息:{}",addr);

        // 如果地址信息为空，则使用在线服务获取
        if(StringUtils.isEmpty(addr)) {
            addr = AddressUtils.getRealAddressByIP(ip);
        }

        // 根据地址信息过滤特定国家或省份
        if (addr.contains("China") || addr.contains("Beijing")) {
            log.info("Request from China or Beijing: IP >> {}, Address >> {}", ip, addr);
            // 根据业务需求进行处理
        }

        Map<String, Object> map = new HashMap<>();
        map.put("msg", "HelloWorld");
        map.put("ipaddr", addr);
        return map;
    }


    /**
     * 组合使用多个工具类获取详细地理信息
     * @param httpServletRequest
     * @param httpServletResponse
     * @param ip ip地址
     * @return
     */
    @GetMapping("/getDetailedAddress")
    public Map<String, Object> getDetailedAddress(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse,@RequestParam String ip){
        // 从请求中获取实际的客户端IP地址
        ip = IPOfflineUtil.getIpAddr(httpServletRequest);
        log.info("实际的客户端IP地址:{}",ip);
        // 使用默认数据库路径获取缓存的地理位置信息
        String addr = searcherIPUtils.getCachePosition(ip);
        log.info("默认数据库路径获取缓存的地理位置信息:{}",addr);

        // 如果地址信息为空，则使用在线服务获取
        if(StringUtils.isEmpty(addr)) {
            addr = AddressUtils.getRealAddressByIP(ip);
        }

        // 使用CountryInfoDTO存储详细的地理信息
        CountryInfoDTO countryInfo = new CountryInfoDTO();
        countryInfo.setQuery(ip);
        countryInfo.setStatus("success");
        countryInfo.setCountry("SampleCountry");  // 根据你的具体需求设置
        countryInfo.setCity("SampleCity");  // 根据你的具体需求设置
        countryInfo.setRegion("SampleRegion");  // 根据你的具体需求设置
        // 其他字段依次设置...
        log.info("CountryInfoDTO存储详细的地理信息:{}", JSON.toJSONString(countryInfo));

        Map<String, Object> map = new HashMap<>();
        map.put("msg", "HelloWorld");
        map.put("ipaddr", addr);
        map.put("countryInfo", countryInfo);
        return map;
    }


    /**
     * 使用数据库路径和缓存获取索引缓存的地理位置信息
     * @param httpServletRequest
     * @param httpServletResponse
     * @param ip ip地址
     * @return
     */
    @GetMapping("/getIndexCachePosition")
    public Map<String, Object> getIndexCachePosition(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse,@RequestParam String ip){
        // 从请求中获取实际的客户端IP地址
        ip = IPOfflineUtil.getIpAddr(httpServletRequest);

        // 使用数据库路径和缓存获取索引缓存的地理位置信息
        String dbPath = "classpath:ip2region/ip2region.xdb";
        log.info("数据库路径:{}",dbPath);
        String addr = searcherIPUtils.getIndexCachePosition(dbPath, ip, true);
        log.info("缓存获取索引缓存的地理位置信息:{}",addr);

        // 如果地址信息为空，则使用在线服务获取
        if(StringUtils.isEmpty(addr)) {
            addr = AddressUtils.getRealAddressByIP(ip);
        }

        Map<String, Object> map = new HashMap<>();
        map.put("msg", "HelloWorld");
        map.put("ipaddr", addr);
        return map;
    }


    /**
     * 使用指定数据库路径获取地理位置信息
     * @param httpServletRequest
     * @param httpServletResponse
     * @param ip
     * @return
     */
    @GetMapping("/getPosition")
    public Map<String, Object> getPosition(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse,@RequestParam String ip){
        // 从请求中获取实际的客户端IP地址
        ip = IPOfflineUtil.getIpAddr(httpServletRequest);

        // 使用指定数据库路径获取地理位置信息
        String dbPath = "classpath:ip2region/ip2region.xdb";
        log.info("指定数据库路:{}",dbPath);
        String addr = searcherIPUtils.getPosition(dbPath, ip, true);
        log.info("获取地理位置信息:{}",addr);

        // 如果地址信息为空，则使用在线服务获取
        if(StringUtils.isEmpty(addr)) {
            addr = AddressUtils.getRealAddressByIP(ip);
        }

        Map<String, Object> map = new HashMap<>();
        map.put("msg", "HelloWorld");
        map.put("ipaddr", addr);
        return map;
    }


    /**
     * 使用默认数据库路径获取缓存的地理位置信息
     * @param httpServletRequest
     * @param httpServletResponse
     * @param ip ip地址
     * @return
     */
    @GetMapping("/getCachePosition")
    public Map<String, Object> getCachePosition(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse,@RequestParam String ip){
        // 从请求中获取实际的客户端IP地址
        ip = IPOfflineUtil.getIpAddr(httpServletRequest);
        log.info("实际的客户端IP地址:{}",ip);
        // 使用默认数据库路径获取缓存的地理位置信息
        String addr = searcherIPUtils.getCachePosition(ip);
        log.info("获取缓存的地理位置信息:{}",addr);

        // 如果地址信息为空，则使用在线服务获取
        if(StringUtils.isEmpty(addr)) {
            addr = AddressUtils.getRealAddressByIP(ip);
        }

        Map<String, Object> map = new HashMap<>();
        map.put("msg", "HelloWorld");
        map.put("ipaddr", addr);
        return map;
    }
}

3、Data Transfer Object(DTO 封装国家/区域信息)

@Data
@NoArgsConstructor
@AllArgsConstructor
public class CountryInfoRespDTO {

    /**
     * 查询的IP地址
     */
    private String query;

    /**
     * 查询状态（例如成功或失败）
     */
    private String status;

    /**
     * 国家名称
     */
    private String country;

    /**
     * 国家代码（例如 US, CN）
     */
    private String countryCode;

    /**
     * 地区名称
     */
    private String region;

    /**
     * 地区全名
     */
    private String regionName;

    /**
     * 城市名称
     */
    private String city;

    /**
     * 邮政编码
     */
    private String zip;

    /**
     * 纬度
     */
    private String lat;

    /**
     * 经度
     */
    private String lon;

    /**
     * 时区
     */
    private String timezone;

    /**
     * 互联网服务提供商
     */
    private String isp;

    /**
     * 组织名称
     */
    private String org;

    /**
     * Autonomous System (AS) 编号
     */
    private String as;

}

4、ip地址查询工具封装（util）

下载离线IP定位库，离线数据库在项目的data文件夹下，名称为ip2region.db，其他2个文件是用于生成离线库的，可不用下载。

github.com/lionsoul201…

放在项目的resources/ip2region目录

IPOfflineUtil 离线查询工具类

@Slf4j
public class IPOfflineUtil {

    private static final String UNKNOWN = "unknown";
    private static final String LOOPBACK_ADDRESS = "0:0:0:0:0:0:0:1";
    private static final String LOCALHOST = "127.0.0.1";

    // 私有构造函数，禁止实例化
    private IPOfflineUtil() {
    }

    /**
     * 获取客户端真实IP地址
     *
     * @param request HttpServletRequest对象
     * @return 客户端IP地址
     */
    public static String getIpAddr(HttpServletRequest request) {
        String[] headers = {
                "X-Forwarded-For", "Proxy-Client-IP", "WL-Proxy-Client-IP", "HTTP_X_FORWARDED_FOR",
                "HTTP_X_FORWARDED", "HTTP_X_CLUSTER_CLIENT_IP", "HTTP_CLIENT_IP",
                "HTTP_FORWARDED_FOR", "HTTP_FORWARDED", "HTTP_VIA", "REMOTE_ADDR"
        };

        String ip = null;
        for (String header : headers) {
            ip = request.getHeader(header);
            if (StringUtils.hasLength(ip) && !UNKNOWN.equalsIgnoreCase(ip)) {
                break;
            }
        }

        if (!StringUtils.hasLength(ip) || UNKNOWN.equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }

        // 如果IP地址是IPv6的本地地址，转换为IPv4的127.0.0.1
        if (LOOPBACK_ADDRESS.equals(ip)) {
            return LOCALHOST;
        }

        // 如果IP地址包含多个代理服务器地址，取第一个非unknown的IP地址
        if (ip != null && ip.contains(",")) {
            ip = ip.split(",")[0];
        }

        return ip;
    }

    /**
     * 根据IP地址获取物理地址信息
     *
     * @param ip IP地址
     * @return 物理地址信息
     */
    public static String getAddr(String ip) {
        try {
            // 使用当前类的类加载器
            ClassLoader classLoader = IPOfflineUtil.class.getClassLoader();
            // 获取资源 URL
            URL resourceUrl = classLoader.getResource("ip2region/ip2region.xdb");
            if (resourceUrl == null) {
                log.info("Resource not found");
                return null;
            }

            String dbPath = resourceUrl.getPath();
            log.info("dbPath: " + dbPath);

            // 1、读取资源文件内容
            byte[] cBuff = Searcher.loadContentFromFile(dbPath);

            // 2、使用缓存创建查询对象
            Searcher searcher = Searcher.newWithBuffer(cBuff);

            // 3、查询IP地址对应的位置信息
            String region = searcher.search(ip);
            return region;
        } catch (Exception e) {
            e.printStackTrace();
            log.info("failed to search(%s): %s\n", ip, e);
            return null;
        }
    }

}

IPOnlineUtil在线查询访问ip工具类

public class IPOnlineUtil {

    /**
     * 静态RestTemplate实例，用于发送HTTP请求
     */
    private static RestTemplate restTemplate;

    /**
     * 实例RestTemplate，用于初始化静态实例
     */
    private final RestTemplate template;

    /**
     * IP信息API的URL
     */
    public static final String IP_API_URL = "http://ip-api.com/json/";

    /**
     * 构造函数，接收一个RestTemplate实例
     *
     * @param restTemplate RestTemplate实例
     */
    public IPOnlineUtil(RestTemplate restTemplate) {
        this.template = restTemplate;
    }

    /**
     * 初始化方法，在构造函数后调用，用于设置静态RestTemplate实例
     */
    @PostConstruct
    public void init() {
        setRestTemplate(this.template);
    }

    /**
     * 设置静态RestTemplate实例的方法
     */
    private static void setRestTemplate(RestTemplate template) {
        restTemplate = template;
    }

    /**
     * 通过IP地址获取国家信息的方法
     *
     * @param ip IP地址
     * @return 国家信息
     */
    public static CountryInfoDTO getCountryByIpOnline(String ip) {
        // 构建完整的API URL
        String url = String.format("%s%s?lang=zh-CN", IP_API_URL, ip);

        // 发送HTTP GET请求，获取响应
        ResponseEntity<CountryInfoDTO> entity = restTemplate.getForEntity(url, CountryInfoDTO.class);

        // 返回响应体
        return entity.getBody();
    }
}

IP 查询工具类：AddressUtils

@Slf4j
public class AddressUtils {

    /**
     * IP信息查询API的URL
     */
    public static final String IP_URL = "http://whois.pconline.com.cn/ipJson.jsp";

    /**
     * 默认返回的未知地址
     */
    public static final String UNKNOWN = "XX XX";

    /**
     * 通过IP地址获取地理位置信息
     * @param ip IP地址
     * @return 地理位置信息
     */
    public static String getRealAddressByIP(String ip) {
        // 如果IP是内网IP，直接返回内网IP
        if (internalIp(ip)) {
            return "inner IP";
        }
        try {
            // 发送GET请求获取IP地址信息
            String response = sendGet(IP_URL, "ip=" + ip + "&json=true", "GBK");
            if (StringUtils.isEmpty(response)) {
                log.error("获取地址信息异常: {}", ip);
                return UNKNOWN;
            }

            // 解析JSON响应，获取省份和城市信息
            JSONObject obj = JSONObject.parseObject(response);
            String region = obj.getString("pro");
            String city = obj.getString("city");
            return String.format("%s %s", region, city);
        } catch (Exception e) {
            log.error("获取地址信息异常: {}", ip, e);
            return UNKNOWN;
        }
    }

    /**
     * 发送GET请求
     *
     * @param url         请求的URL
     * @param param       请求的参数
     * @param contentType 请求的内容类型
     * @return 响应结果
     */
    public static String sendGet(String url, String param, String contentType) {
        StringBuilder result = new StringBuilder();
        BufferedReader in = null;
        try {
            String urlWithParams = url + "?" + param;
            log.info("发送GET请求: {}", urlWithParams);

            URL realUrl = new URL(urlWithParams);
            URLConnection connection = realUrl.openConnection();
            connection.setRequestProperty("accept", "*/*");
            connection.setRequestProperty("connection", "Keep-Alive");
            connection.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
            connection.connect();

            in = new BufferedReader(new InputStreamReader(connection.getInputStream(), contentType));
            String line;
            while ((line = in.readLine()) != null) {
                result.append(line);
            }
            log.info("接收响应: {}", result);
        } catch (ConnectException e) {
            log.error("发送GET请求异常: 连接失败, url={}, param={}", url, param, e);
        } catch (SocketTimeoutException e) {
            log.error("发送GET请求异常: 超时, url={}, param={}", url, param, e);
        } catch (IOException e) {
            log.error("发送GET请求异常: IO异常, url={}, param={}", url, param, e);
        } catch (Exception e) {
            log.error("发送GET请求异常: 异常, url={}, param={}", url, param, e);
        } finally {
            try {
                if (in != null) {
                    in.close();
                }
            } catch (Exception ex) {
                log.error("关闭输入流异常: url={}, param={}", url, param, ex);
            }
        }
        return result.toString();
    }


    /**
     * 检查IP地址是否为内网IP
     *
     * @param ip IP地址
     * @return 如果是内网IP返回true，否则返回false
     */
    public static boolean internalIp(String ip) {
        byte[] addr = textToNumericFormatV4(ip);
        return internalIp(addr) || "127.0.0.1".equals(ip);
    }

    /**
     * 检查字节数组形式的IP地址是否为内网IP
     *
     * @param addr 字节数组形式的IP地址
     * @return 如果是内网IP返回true，否则返回false
     */
    private static boolean internalIp(byte[] addr) {
        if (addr == null || addr.length < 2) {
            return true;
        }
        final byte b0 = addr[0];
        final byte b1 = addr[1];
        // 10.x.x.x/8
        final byte SECTION_1 = 0x0A;
        // 172.16.x.x/12
        final byte SECTION_2 = (byte) 0xAC;
        final byte SECTION_3 = (byte) 0x10;
        final byte SECTION_4 = (byte) 0x1F;
        // 192.168.x.x/16
        final byte SECTION_5 = (byte) 0xC0;
        final byte SECTION_6 = (byte) 0xA8;
        switch (b0) {
            case SECTION_1:
                return true;
            case SECTION_2:
                return (b1 >= SECTION_3 && b1 <= SECTION_4);
            case SECTION_5:
                return (b1 == SECTION_6);
            default:
                return false;
        }
    }

    /**
     * 将IPv4地址转换为字节数组
     *
     * @param text IPv4地址字符串
     * @return 字节数组形式的IP地址
     */
    private static byte[] textToNumericFormatV4(String text) {
        if (text.length() == 0) {
            return new byte[0];
        }

        byte[] bytes = new byte[4];
        String[] elements = text.split("\.", -1);
        try {
            long l;
            int i;
            switch (elements.length) {
                case 1:
                    l = Long.parseLong(elements[0]);
                    if (l < 0L || l > 4294967295L) {
                        return new byte[0];
                    }
                    bytes[0] = (byte) (int) (l >> 24 & 0xFF);
                    bytes[1] = (byte) (int) ((l & 0xFFFFFF) >> 16 & 0xFF);
                    bytes[2] = (byte) (int) ((l & 0xFFFF) >> 8 & 0xFF);
                    bytes[3] = (byte) (int) (l & 0xFF);
                    break;
                case 2:
                    l = Integer.parseInt(elements[0]);
                    if (l < 0L || l > 255L) {
                        return new byte[0];
                    }
                    bytes[0] = (byte) (int) (l & 0xFF);
                    l = Integer.parseInt(elements[1]);
                    if (l < 0L || l > 16777215L) {
                        return new byte[0];
                    }
                    bytes[1] = (byte) (int) (l >> 16 & 0xFF);
                    bytes[2] = (byte) (int) ((l & 0xFFFF) >> 8 & 0xFF);
                    bytes[3] = (byte) (int) (l & 0xFF);
                    break;
                case 3:
                    for (i = 0; i < 2; ++i) {
                        l = Integer.parseInt(elements[i]);
                        if (l < 0L || l > 255L) {
                            return new byte[0];
                        }
                        bytes[i] = (byte) (int) (l & 0xFF);
                    }
                    l = Integer.parseInt(elements[2]);
                    if (l < 0L || l > 65535L) {
                        return new byte[0];
                    }
                    bytes[2] = (byte) (int) (l >> 8 & 0xFF);
                    bytes[3] = (byte) (int) (l & 0xFF);
                    break;
                case 4:
                    for (i = 0; i < 4; ++i) {
                        l = Integer.parseInt(elements[i]);
                        if (l < 0L || l > 255L) {
                            return new byte[0];
                        }
                        bytes[i] = (byte) (int) (l & 0xFF);
                    }
                    break;
                default:
                    return new byte[0];
            }
        } catch (NumberFormatException e) {
            return new byte[0];
        }
        return bytes;
    }
}

IP 查询工具类：SearcherIPUtils

@Component
public class SearcherIPUtils {

    private final ResourceLoader resourceLoader;

    @Autowired
    public SearcherIPUtils(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
    }

    // 默认数据库路径
    private static final String DEFAULT_DB_PATH =  "classpath:ip2region/ip2region.xdb";

    /**
     * 根据IP地址获取缓存的地理位置信息
     *
     * @param ip IP地址
     * @return 地理位置信息
     */
    public String getCachePosition(String ip) {
        return getCachePosition(DEFAULT_DB_PATH, ip, true);
    }

    /**
     * 根据IP地址和数据库路径获取地理位置信息
     *
     * @param dbPath 数据库文件路径
     * @param ip     IP地址
     * @param format 是否格式化输出
     * @return 地理位置信息
     */
    public String getPosition(String dbPath, String ip, boolean format) {
        Searcher searcher = null;
        try {
            Resource resource = resourceLoader.getResource(dbPath);
            searcher = Searcher.newWithFileOnly(resource.getFile().getPath());
            String region = searcher.search(ip);
            return format ? region : formatRegion(region);
        } catch (Exception e) {
            throw new RuntimeException("Error creating searcher object", e);
        } finally {
            if (searcher != null) {
                try {
                    searcher.close();
                } catch (IOException e) {
                    // 记录关闭异常
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 根据IP地址和数据库路径获取索引缓存的地理位置信息
     *
     * @param dbPath 数据库文件路径
     * @param ip     IP地址
     * @param format 是否格式化输出
     * @return 地理位置信息
     */
    public String getIndexCachePosition(String dbPath, String ip, boolean format) {
        Searcher searcher = null;
        try {
            Resource resource = resourceLoader.getResource(dbPath);
            byte[] vIndex = Searcher.loadVectorIndexFromFile(resource.getFile().getPath());
            searcher = Searcher.newWithVectorIndex(resource.getFile().getPath(), vIndex);
            String region = searcher.search(ip);
            return format ? region : formatRegion(region);
        } catch (Exception e) {
            throw new RuntimeException("Error creating searcher object with vector index", e);
        } finally {
            if (searcher != null) {
                try {
                    searcher.close();
                } catch (IOException e) {
                    // 记录关闭异常
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 根据IP地址和数据库路径获取缓存的地理位置信息
     *
     * @param dbPath 数据库文件路径
     * @param ip     IP地址
     * @param format 是否格式化输出
     * @return 地理位置信息
     */
    public String getCachePosition(String dbPath, String ip, boolean format) {
        Searcher searcher = null;
        try {
            Resource resource = resourceLoader.getResource(dbPath);
            byte[] cBuff = Files.readAllBytes(resource.getFile().toPath());
            searcher = Searcher.newWithBuffer(cBuff);
            String region = searcher.search(ip);
            return format ? region : formatRegion(region);
        } catch (Exception e) {
            throw new RuntimeException("Error loading content from file", e);
        } finally {
            if (searcher != null) {
                try {
                    searcher.close();
                } catch (IOException e) {
                    // 记录关闭异常
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 格式化地理位置信息
     *
     * @param region 原始地理位置信息
     * @return 格式化后的地理位置信息
     */
    private String formatRegion(String region) {
        String[] split = region.split("\|");
        return split[0] + split[2] + split[3];
    }
}

离线 IP 定位库 Ip2region 的使用及工具封装详解

1、什么是ip2region？

2、Ip2region 特性

1、标准化的数据格式

2、数据去重和压缩

3、极速查询响应

4、IP 数据管理框架

3、基于 ip2region 的业务场景应用

1. 内容分发网络（CDN）优化

2. 跨境电商的地区定向营销

3. 金融风控与交易拦截

4. 网络访问权限控制

5. 广告投放精准定位

6. 在线教育的地区分布统计与资源优化

7. 游戏服务器的就近接入

8. 舆情分析与地域热点追踪

9. 直播平台或在线视频的版权保护

10. 物流与配送服务的区域划分

4、代码示例

1、依赖引入

2、controller控制层代码

3、Data Transfer Object(DTO 封装国家/区域信息)

4、ip地址查询工具封装（util）

3、基于 `ip2region` 的业务场景应用