无需request对象获取当前的IP信息，非127.0.0.1

原创已于 2024-02-21 14:30:21 修改 · 1.6k 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#java

于 2018-08-13 11:42:41 首次发布

工具专栏收录该内容

34 篇文章

订阅专栏

本文介绍了一个用于获取客户端IP地址的Java实用程序类。该类能够有效地处理直接连接和通过代理服务器的情况，确保获取到准确的IP地址信息。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

package com.suyun.utils;

import com.google.common.collect.Lists;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.servlet.http.HttpServletRequest;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.Enumeration;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @Description：获取客户端IP信息
 * @Author： leo.xiong
 * @CreateDate： 2019/1/8 15:16
 * @Email： leo.xiong@suyun360.com
 * @Version：
 */
public final class NetworkUtil {
    private static final Logger LOGGER = LoggerFactory.getLogger(NetworkUtil.class);
    public static final String COMMA = ",";

    public static final String COLON = ":";

    public static String IP = "";

    private static final String UNKNOWN = "unknown";

    private static final int MAX_IP_LENGTH = 15;

    private static final int MIN_IP_LENGTH = 7;

    public static final String LOCAL_HOST = "127.0.0.1";

    public static final List<String> IP_LIST = Lists.newArrayList();

    /**
     * 获取服务器IP地址
     */
    static {
        try {
            Enumeration netInterfaces = NetworkInterface.getNetworkInterfaces();
            while (netInterfaces.hasMoreElements()) {
                Enumeration<InetAddress> ni = ((NetworkInterface) netInterfaces.nextElement()).getInetAddresses();
                String ip;
                if (ni.hasMoreElements()) {
                    ip = ni.nextElement().getHostAddress();
                    if (StringUtils.isEmpty(ip)) {
                        continue;
                    }
                    if (!LOCAL_HOST.equals(ip) && ip.indexOf(COLON) == -1 && isIP(ip)) {
                        if (StringUtils.isEmpty(IP)) {
                            IP = ip;
                            LOGGER.info("当前机器受用的IP是" + IP);
                        }
                        IP_LIST.add(ip);
                    }
                }
            }
            LOGGER.info("所有的IP信息:{}", IP_LIST);
        } catch (SocketException e) {
            LOGGER.error("获取当前服务器IP失败" + e);
        }
    }

    public static boolean isIP(String addr) {
        if (addr.length() < MIN_IP_LENGTH || addr.length() > MAX_IP_LENGTH || "".equals(addr)) {
            return false;
        }
        /**
         * 判断IP格式和范围
         */
        String rexp = "([1-9]|[1-9]\\d|1\\d{2}|2[0-4]\\d|25[0-5])(\\.(\\d|[1-9]\\d|1\\d{2}|2[0-4]\\d|25[0-5])){3}";
        Pattern pat = Pattern.compile(rexp);
        Matcher mat = pat.matcher(addr);
        boolean ipAddress = mat.find();
        return ipAddress;
    }

    /**
     * 获取请求主机IP地址,如果通过代理进来，则透过防火墙获取真实IP地址;
     *
     * @param request
     * @return
     */
    public final static String getIpAddress(HttpServletRequest request) {
        // 获取请求主机IP地址,如果通过代理进来，则透过防火墙获取真实IP地址
        String ip = request.getHeader("X-Forwarded-For");
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("getIpAddress(HttpServletRequest) - X-Forwarded-For - String ip=" + ip);
        }
        if (StringUtils.isEmpty(ip) || UNKNOWN.equalsIgnoreCase(ip)) {
            if (StringUtils.isEmpty(ip) || UNKNOWN.equalsIgnoreCase(ip)) {
                ip = request.getHeader("Proxy-Client-IP");
                if (LOGGER.isDebugEnabled()) {
                    LOGGER.debug("getIpAddress(HttpServletRequest) - Proxy-Client-IP - String ip=" + ip);
                }
            }
            if (StringUtils.isEmpty(ip) || UNKNOWN.equalsIgnoreCase(ip)) {
                ip = request.getHeader("WL-Proxy-Client-IP");
                if (LOGGER.isDebugEnabled()) {
                    LOGGER.debug("getIpAddress(HttpServletRequest) - WL-Proxy-Client-IP - String ip=" + ip);
                }
            }
            if (StringUtils.isEmpty(ip) || UNKNOWN.equalsIgnoreCase(ip)) {
                ip = request.getHeader("HTTP_CLIENT_IP");
                if (LOGGER.isDebugEnabled()) {
                    LOGGER.debug("getIpAddress(HttpServletRequest) - HTTP_CLIENT_IP - String ip=" + ip);
                }
            }
            if (StringUtils.isEmpty(ip) || UNKNOWN.equalsIgnoreCase(ip)) {
                ip = request.getHeader("HTTP_X_FORWARDED_FOR");
                if (LOGGER.isDebugEnabled()) {
                    LOGGER.debug("getIpAddress(HttpServletRequest) - HTTP_X_FORWARDED_FOR - String ip=" + ip);
                }
            }
            if (StringUtils.isEmpty(ip) || UNKNOWN.equalsIgnoreCase(ip)) {
                ip = request.getRemoteAddr();
                if (LOGGER.isDebugEnabled()) {
                    LOGGER.debug("getIpAddress(HttpServletRequest) - getRemoteAddr - String ip=" + ip);
                }
            }
        } else if (ip.length() > MAX_IP_LENGTH) {
            String[] ips = ip.split(COMMA);
            for (int index = 0; index < ips.length; index++) {
                String strIp = ips[index];
                if (!(UNKNOWN.equalsIgnoreCase(strIp))) {
                    ip = strIp;
                    break;
                }
            }
        }
        return ip;
    }

    public static void main(String[] args) {
        System.out.println(NetworkUtil.IP_LIST);
    }
}