IP地址工具类

package com.leng.demo.utils;

import jakarta.servlet.http.HttpServletRequest;

import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.nio.ByteBuffer;
import java.util.Arrays;

/**
 * IP地址工具类，提供常用的IP地址操作方法，
 * 支持IPv4和IPv6两种协议版本
 */
public final class IpUtil {
    private static final String UNKNOWN = "unknown";

    private IpUtil() {
    }

    /**
     * 判断是否为合法的IP地址
     *
     * @param ipAddress 需要判断的IP地址
     * @return 返回 true 表示是合法IP地址，false 表示不是合法IP地址
     */
    public static boolean isIpAddress(String ipAddress) {
        if (ipAddress == null || ipAddress.length() == 0) {
            return false;
        }
        try {
            InetAddress address = InetAddress.getByName(ipAddress);
            return address instanceof Inet4Address || address instanceof Inet6Address;
        } catch (UnknownHostException e) {
            return false;
        }
    }

    /**
     * 判断是否为IPv4地址
     *
     * @param ipAddress IP地址
     * @return 如果是IPv4地址，则返回true；如果不是IPv4地址或者为空，则返回false
     */
    public static boolean isIpv4(String ipAddress) {
        if (ipAddress == null || ipAddress.length() == 0) {
            return false;
        }
        try {
            return InetAddress.getByName(ipAddress) instanceof Inet4Address;
        } catch (UnknownHostException e) {
            return false;
        }
    }

    /**
     * 判断是否为IPv6地址
     *
     * @param ipAddress IP地址
     * @return 如果是IPv6地址，则返回true；如果不是IPv6地址或者为空，则返回false
     */
    public static boolean isIpv6(String ipAddress) {
        if (ipAddress == null || ipAddress.length() == 0) {
            return false;
        }
        try {
            return InetAddress.getByName(ipAddress) instanceof Inet6Address;
        } catch (UnknownHostException e) {
            return false;
        }
    }

    /**
     * 把字符串类型IPv4地址转换成long类型的整数
     *
     * @param ipAddress IPv4地址，例如192.168.1.1
     * @return 返回转换后的长整数，如果参数不合法则返回0
     */
    public static long ipv4ToLong(String ipAddress) {
        if (!isIpv4(ipAddress)) {
            return 0;
        }
        String[] ipArray = ipAddress.split("\\.");
        long result = 0;
        for (int i = 0; i < 4; i++) {
            result |= Long.parseLong(ipArray[i]) << ((3 - i) * 8);
        }
        return result;
    }

    /**
     * 把网络序（大端序）IPv4地址转换成字符串格式
     *
     * @param ipValue IPv4地址的长整数表示，如：3232235777
     * @return 返回格式为x.x.x.x的IPv4地址字符串，如果参数不合法则返回空串
     */
    public static String longToIpv4(long ipValue) {
        if (ipValue < 0 || ipValue > 0xFFFFFFFFL) {
            return "";
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 4; i++) {
            sb.insert(0, Long.toString(ipValue & 0xff));
            if (i < 3) {
                sb.insert(0, '.');
            }
            ipValue >>= 8;
        }
        return sb.toString();
    }

    /**
     * 把字符串类型IPv6地址转换成byte数组
     *
     * @param ipAddress IPv6地址，例如：fe80::8364:4dbf:2777:48ab
     * @return 返回表示IPv6地址的byte数组，如果参数不合法则返回null
     */
    public static byte[] ipv6ToBytes(String ipAddress) {
        if (!isIpv6(ipAddress)) {
            return null;
        }
        InetAddress address;
        try {
            address = InetAddress.getByName(ipAddress);
            return address.getAddress();
        } catch (UnknownHostException e) {
            return null;
        }
    }

    /**
     * 把byte数组类型IPv6地址转换成字符串格式
     *
     * @param ipv6Bytes IPv6地址的byte数组表示
     * @return 返回ipv6地址字符串，如果参数不合法则返回空串
     */
    public static String bytesToIpv6(byte[] ipv6Bytes) throws UnknownHostException {
        if (ipv6Bytes == null || ipv6Bytes.length != 16) {
            return "";
        }
        ByteBuffer buffer = ByteBuffer.allocate(16);
        buffer.put(ipv6Bytes);
        buffer.flip();
        return InetAddress.getByAddress(buffer.array()).getHostAddress();
    }

    /**
     * 获取当前访问的IP地址
     *
     * @param request 当前请求
     * @return 返回当前请求的IP地址，如果获取失败则返回空串
     */
    public static String getClientIp(HttpServletRequest request) {
        if (request == null) {
            return "";
        }
        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.getHeader("HTTP_CLIENT_IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("HTTP_X_FORWARDED_FOR");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        return ip;
    }


    /**
     * 获取 IP地址
     * 使用 Nginx等反向代理软件， 则不能通过 request.getRemoteAddr()获取 IP地址
     * 如果使用了多级反向代理的话，X-Forwarded-For的值并不止一个，而是一串IP地址，
     * X-Forwarded-For中第一个非 unknown的有效IP字符串，则为真实IP地址
     */
    public static String getIpAddr(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();
        }
        return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : ip;
    }
}