Java中高效获取IP地域信息方案全解析

import org.lionsoul.ip2region.xdb.Searcher;
import java.io.*;
import java.util.concurrent.TimeUnit;

/**
 * 高性能IP地域查询工具类
 * 适用于高并发场景下的IP地域信息查询
 */
public class IP2RegionUtil {
    private Searcher searcher;
    private boolean isInitialized = false;

    /**
     * 初始化IP2Region数据库
     * @param dbPath 数据库文件路径，支持classpath和绝对路径
     */
    public void init(String dbPath) {
        try {
            // 处理classpath路径
            if (dbPath.startsWith("classpath:")) {
                String resourcePath = dbPath.substring(10);
                InputStream inputStream = getClass().getClassLoader().getResourceAsStream(resourcePath);
                if (inputStream == null) {
                    throw new FileNotFoundException("IP数据库文件未找到: " + resourcePath);
                }
                
                // 创建临时文件
                File tempFile = File.createTempFile("ip2region", ".xdb");
                tempFile.deleteOnExit();
                
                try (FileOutputStream out = new FileOutputStream(tempFile)) {
                    byte[] buffer = new byte[1024];
                    int bytesRead;
                    while ((bytesRead = inputStream.read(buffer)) != -1) {
                        out.write(buffer, 0, bytesRead);
                    }
                }
                dbPath = tempFile.getAbsolutePath();
            }

            // 创建搜索器
            searcher = Searcher.newWithFileOnly(dbPath);
            isInitialized = true;
            System.out.println("IP2Region初始化成功");
            
        } catch (Exception e) {
            System.err.println("IP2Region初始化失败: " + e.getMessage());
            e.printStackTrace();
        }
    }

    /**
     * 获取IP地域信息
     * @param ip IP地址
     * @return 地域信息字符串
     */
    public String searchIP(String ip) {
        if (!isInitialized) {
            return "IP数据库未初始化";
        }

        try {
            long startTime = System.nanoTime();
            String region = searcher.search(ip);
            long cost = TimeUnit.NANOSECONDS.toMicros(System.nanoTime() - startTime);
            
            System.out.printf("IP查询耗时: %d μs%n", cost);
            return region;
            
        } catch (Exception e) {
            return "IP查询失败: " + e.getMessage();
        }
    }

    /**
     * 解析地域信息为结构化数据
     * @param ip IP地址
     * @return IPInfo对象
     */
    public IPInfo parseIPInfo(String ip) {
        String region = searchIP(ip);
        return parseRegionString(region);
    }

    /**
     * 解析地域字符串
     * @param region 地域字符串
     * @return IPInfo对象
     */
    public IPInfo parseRegionString(String region) {
        if (region == null || region.isEmpty() || region.contains("失败") || region.contains("未初始化")) {
            return new IPInfo("未知", "未知", "未知", "未知", "未知");
        }

        String[] parts = region.split("\\|");
        if (parts.length < 5) {
            return new IPInfo("未知", "未知", "未知", "未知", "未知");
        }

        return new IPInfo(
            "0".equals(parts[0]) ? "未知" : parts[0], // 国家
            "0".equals(parts[1]) ? "未知" : parts[1], // 区域
            "0".equals(parts[2]) ? "未知" : parts[2], // 省份
            "0".equals(parts[3]) ? "未知" : parts[3], // 城市
            "0".equals(parts[4]) ? "未知" : parts[4]  // ISP
        );
    }

    /**
     * 关闭资源（重要！）
     */
    public void close() {
        if (searcher != null) {
            try {
                searcher.close();
                isInitialized = false;
                System.out.println("IP2Region资源已释放");
            } catch (IOException e) {
                System.err.println("关闭IP2Region资源时出错: " + e.getMessage());
            }
        }
    }

    /**
     * IP信息实体类
     */
    public static class IPInfo {
        private String country;
        private String region;
        private String province;
        private String city;
        private String isp;

        public IPInfo(String country, String region, String province, String city, String isp) {
            this.country = country;
            this.region = region;
            this.province = province;
            this.city = city;
            this.isp = isp;
        }

        // Getter方法
        public String getCountry() { return country; }
        public String getRegion() { return region; }
        public String getProvince() { return province; }
        public String getCity() { return city; }
        public String getIsp() { return isp; }

        @Override
        public String toString() {
            return String.format("国家: %s, 省份: %s, 城市: %s, ISP: %s", 
                country, province, city, isp);
        }
    }
}

/**
 * 高频调用场景下的IP查询优化方案
 */
public class HighFrequencyIPExample {
    
    private final IP2RegionUtil ipUtil;
    
    public HighFrequencyIPExample() {
        ipUtil = new IP2RegionUtil();
        ipUtil.init("classpath:ip2region.xdb");
    }
    
    /**
     * 批量处理IP消息的高效分析方法
     */
    public AnalysisResult analyzeMessages(List<IpMessage> messages) {
        int totalCount = messages.size();
        int consistentCount = 0;
        int inconsistentCount = 0;
        List<String> inconsistentExamples = new ArrayList<>();
        List<String> inconsistentRegionExamples = new ArrayList<>();
        Map<String, Integer> ipFrequency = new HashMap<>();

        // 优化点1: 先收集所有需要查询的IP
        Set<String> allIps = new HashSet<>();
        for (IpMessage message : messages) {
            if (message != null) {
                allIps.add(message.getRequestIp());
                allIps.add(message.getReportIp());
            }
        }

        // 优化点2: 批量查询IP地域信息
        Map<String, String> ipRegionMap = new HashMap<>();
        for (String ip : allIps) {
            ipRegionMap.put(ip, ipUtil.parseIPInfo(ip).toString());
        }

        // 处理每条消息
        for (IpMessage message : messages) {
            if (message == null) {
                continue;
            }

            // 统计IP频率
            countIpFrequency(ipFrequency, message.getRequestIp());
            countIpFrequency(ipFrequency, message.getReportIp());

            if (message.getRequestIp().equals(message.getReportIp())) {
                consistentCount++;
            } else {
                inconsistentCount++;
                // 记录不一致案例（最多记录100个）
                if (inconsistentExamples.size() < 100) {
                    inconsistentExamples.add(message.getRequestIp() + ":" + message.getReportIp());

                    // 从缓存map中获取地域信息
                    String requestRegion = ipRegionMap.get(message.getRequestIp());
                    String reportRegion = ipRegionMap.get(message.getReportIp());
                    inconsistentRegionExamples.add(requestRegion + ":" + reportRegion);
                }
            }
        }

        return buildResult(totalCount, consistentCount, inconsistentCount, 
                          inconsistentExamples, inconsistentRegionExamples, ipFrequency);
    }
    
    private void countIpFrequency(Map<String, Integer> frequencyMap, String ip) {
        frequencyMap.put(ip, frequencyMap.getOrDefault(ip, 0) + 1);
    }
    
    // 清理资源
    public void destroy() {
        if (ipUtil != null) {
            ipUtil.close();
        }
    }
}

# application.yml
ip2region:
  db-path: classpath:ip2region.xdb
  cache:
    enabled: true
    maximum-size: 10000
    expire-hours: 24

@Configuration
@EnableCaching
public class IP2RegionConfig {
    
    @Value("${ip2region.db-path:classpath:ip2region.xdb}")
    private String dbPath;
    
    @Bean
    public IP2RegionUtil ip2RegionUtil() throws IOException {
        IP2RegionUtil util = new IP2RegionUtil();
        util.init(dbPath);
        return util;
    }
    
    @Bean
    public CacheManager cacheManager() {
        return new ConcurrentMapCacheManager("ipRegionCache");
    }
}

@Service
public class IPLocationService {
    
    private final IP2RegionUtil ip2RegionUtil;
    private final CacheManager cacheManager;
    
    public IPLocationService(IP2RegionUtil ip2RegionUtil, CacheManager cacheManager) {
        this.ip2RegionUtil = ip2RegionUtil;
        this.cacheManager = cacheManager;
    }
    
    /**
     * 带缓存的IP查询方法
     */
    @Cacheable(value = "ipRegionCache", key = "#ip")
    public IP2RegionUtil.IPInfo getIPInfoWithCache(String ip) {
        return ip2RegionUtil.parseIPInfo(ip);
    }
    
    /**
     * 批量查询IP信息
     */
    public Map<String, IP2RegionUtil.IPInfo> batchGetIPInfo(List<String> ips) {
        Map<String, IP2RegionUtil.IPInfo> result = new HashMap<>();
        Cache cache = cacheManager.getCache("ipRegionCache");
        
        for (String ip : ips) {
            Cache.ValueWrapper wrapper = cache != null ? cache.get(ip) : null;
            if (wrapper != null) {
                // 从缓存中获取
                result.put(ip, (IP2RegionUtil.IPInfo) wrapper.get());
            } else {
                // 查询并缓存结果
                IP2RegionUtil.IPInfo info = ip2RegionUtil.parseIPInfo(ip);
                result.put(ip, info);
                if (cache != null) {
                    cache.put(ip, info);
                }
            }
        }
        
        return result;
    }
    
    @PreDestroy
    public void destroy() {
        if (ip2RegionUtil != null) {
            ip2RegionUtil.close();
        }
    }
}

public class IP2RegionPerformanceTest {
    
    public static void main(String[] args) {
        IP2RegionUtil ipUtil = new IP2RegionUtil();
        
        try {
            ipUtil.init("classpath:ip2region.xdb");
            
            // 预热
            warmUp(ipUtil);
            
            // 性能测试
            int iterations = 100000;
            long startTime = System.currentTimeMillis();
            
            for (int i = 0; i < iterations; i++) {
                String randomIP = generateRandomIP();
                ipUtil.searchIP(randomIP);
            }
            
            long totalTime = System.currentTimeMillis() - startTime;
            double avgTime = (double) totalTime / iterations;
            
            System.out.printf("总查询次数: %d%n", iterations);
            System.out.printf("总耗时: %d ms%n", totalTime);
            System.out.printf("平均每次查询耗时: %.3f ms%n", avgTime);
            System.out.printf("QPS: %.0f%n", 1000 / avgTime);
            
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            ipUtil.close();
        }
    }
    
    private static void warmUp(IP2RegionUtil ipUtil) {
        for (int i = 0; i < 1000; i++) {
            ipUtil.searchIP(generateRandomIP());
        }
    }
    
    private static String generateRandomIP() {
        return (int)(Math.random() * 255) + "." +
               (int)(Math.random() * 255) + "." +
               (int)(Math.random() * 255) + "." +
               (int)(Math.random() * 255);
    }
}

@Component
public class MultiSourceIPLocator {
    
    @Autowired(required = false)
    private IP2RegionUtil ip2RegionUtil;
    
    @Value("${ip.location.fallback.enabled:true}")
    private boolean fallbackEnabled;
    
    /**
     * 多数据源IP查询策略
     */
    public IPLocationResult resolveIP(String ip) {
        // 首选IP2Region
        try {
            if (ip2RegionUtil != null) {
                IP2RegionUtil.IPInfo info = ip2RegionUtil.parseIPInfo(ip);
                if (!"未知".equals(info.getCountry())) {
                    return IPLocationResult.success(info, "ip2region");
                }
            }
        } catch (Exception e) {
            // 记录日志但继续尝试备用方案
            log.warn("IP2Region查询失败: {}", e.getMessage());
        }
        
        // 备用方案：在线API
        if (fallbackEnabled) {
            try {
                String region = OnlineIPAPI.getLocation(ip);
                return IPLocationResult.success(parseOnlineResult(region), "online-api");
            } catch (Exception e) {
                log.warn("在线API查询失败: {}", e.getMessage());
            }
        }
        
        return IPLocationResult.fail("所有数据源查询失败");
    }
}