IP 相关工具类

import com.gaolv.utils.core.StrUtil;
import com.gaolv.web.constant.Constants;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import lombok.extern.log4j.Log4j2;

import javax.annotation.Nullable;
import javax.servlet.http.HttpServletRequest;
import java.util.regex.Pattern;

/**
 * 描述：IP 相关工具类
 *
 */
@Log4j2
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public final class IpUtils {
    private static final Pattern IP = Pattern.compile("((\\d+\\.){3}\\d+)");

    /**
     * url 辅助工具，将给定的 url 切割成 uri
     *
     * @param url 需要处理的 url
     * @param contextPath 请求上下文路径，需要根据该路径进行正则匹配
     * @return 切割之后的 uri
     */
    public static String url(String url, String contextPath) {
        var format = String.format("(%s.*)", contextPath);
        var m = Pattern.compile(format).matcher(url);
        if (m.find()) {
            return m.group(0);
        }
        return "";
    }

    /**
     * 从 url 中提取 ip 地址
     * <p>
     * 注意，由于 Actuator 曝露的端点（K8s 监控）是无法获取到 request 上下文对象的，所以需要使用该方法
     *
     * @param url 待提取的 url
     * @return 返回 ip 地址，如果不合法或者不存在返回 ""
     */
    public static String exactIp(String url) {
        // 如果是 localhost 则转换成 ip 地址
        if (url.contains(Constants.LOCALHOST)) {
            url = url.replace(Constants.LOCALHOST, Constants.LOCALHOST_IP);
        }
        var matcher = IP.matcher(url);
        if (matcher.find()) {
            return matcher.group(0);
        }
        return StrUtil.EMPTY;
    }

    /**
     * 从当前请求的上下文中获取请求对象，并解析出请求 ip
     *
     * @return 返回当前请求的 ip 地址，如果不合法或者不存在返回 ""
     */
    public static String exactIp() {
        return WebUtils.getCurrentRequest().map(HttpServletRequest::getRemoteHost).orElse(StrUtil.EMPTY);
    }

    /**
     * 将 host 与 ip 地址互转
     *
     * @param url 需要转化的 url
     * @return 返回转化后的 url
     */
    public static String localhostConvert(String url) {
        if (url.contains(Constants.LOCALHOST)) {
            return url.replace(Constants.LOCALHOST, Constants.LOCALHOST_IP);
        } else {
            return url.replace(Constants.LOCALHOST_IP, Constants.LOCALHOST);
        }
    }

    /**
     * 用于判断IP是否为私有IP（内网IP）或者环回地址,如果是公网域名（直接解析失败）直接返回 false
     *
     * @param ip 需要判断的 ip地址
     * @return 如果是内网的 ip 返回 true
     */
    public static boolean isInnerIp(String ip) {
        try {
            var ipNum = getIpNum(ip);
            var aBegin = getIpNum("10.0.0.0");
            var aEnd = getIpNum("10.255.255.255");
            var bBegin = getIpNum("172.16.0.0");
            var bEnd = getIpNum("172.31.255.255");
            var cBegin = getIpNum("192.168.0.0");
            var cEnd = getIpNum("192.168.255.255");
            var ringBegin = getIpNum("127.0.0.0");
            var ringEnd = getIpNum("127.255.255.255");

            return isInner(ipNum, aBegin, aEnd) || isInner(ipNum, bBegin, bEnd)
                || isInner(ipNum, cBegin, cEnd) || isInner(ipNum, ringBegin, ringEnd);
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 将IP转换为数字
     *
     * @param ip 待转换的 ip
     * @return 返回数字 ip
     */
    private static long getIpNum(String ip) {
        var ipArray = ip.split("\\.");
        var a = Integer.parseInt(ipArray[0]);
        var b = Integer.parseInt(ipArray[1]);
        var c = Integer.parseInt(ipArray[2]);
        var d = Integer.parseInt(ipArray[3]);
        return (long)a * 256 * 256 * 256 + b * 256 * 256 + c * 256 + d;
    }

    /**
     * 判断IP转化后的数字是否是区间内
     *
     * @param ipNum ip 数字地址
     * @param begin 开始 ip 区间
     * @param end 结束 ip 区间
     * @return 如果在指定的 ip 区间内返回 true
     */
    private static boolean isInner(long ipNum, long begin, long end) {
        return (ipNum >= begin) && (ipNum <= end);
    }
}