IP工具类

已于 2025-01-07 18:10:07 修改
阅读量102 收藏
点赞数 1
文章标签： tcp/ip 网络协议 网络
于 2024-11-25 13:53:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/johnrui/article/details/144025738
版权

IP工具类

public class IPUtils {
    private static Logger logger = LoggerFactory.getLogger(IPUtils.class);
    private static final String REG_EXP_IP = "([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}";
    private static final String CMD_GET_HOST_IP = "ifconfig {0} | grep \"inet addr\" | awk ''$1==\"inet\" '{print $2'}'' | awk -F: '''{print $2'}''";
    private static final String CMD_GET_HOST_IP_OS7 = "ifconfig {0} | grep \"inet\" | awk ''$1==\"inet\" '{print $2'}''";
    private static final String CONFIG_DEFAULT_NETWORK = "/etc/network/default_gw";

    public IPUtils() {
    }

    public static String getHostName() {
        String hostName = System.getenv("COMPUTERNAME");
        if (!StringUtils.isEmpty(hostName)) {
            return hostName;
        } else {
            try {
                InetAddress inetAddress = Inet4Address.getLocalHost();
                if (inetAddress != null) {
                    hostName = inetAddress.getHostName();
                }
            } catch (UnknownHostException var4) {
                String host = var4.getMessage();
                if (!StringUtils.isEmpty(host)) {
                    int colon = host.indexOf(":");
                    if (colon > 0) {
                        hostName = host.substring(0, colon);
                    }
                }
            }

            return hostName;
        }
    }

    public static String getHostIp(String networkName) {
        String hostIp = "";
        if (OSCategory.WINDOWS.equals(OSCategory.currentOS())) {
            try {
                hostIp = InetAddress.getLocalHost().getHostAddress();
                if (logger.isDebugEnabled()) {
                    logger.debug("get host ip (windows) success: {}", hostIp);
                }
            } catch (UnknownHostException var3) {
                logger.error("get host ip (windows) failed", var3);
            }
        } else if (StringUtils.isEmpty(networkName)) {
            hostIp = getHostIp();
        } else {
            hostIp = getLinuxHostIpByCmd(networkName);
        }

        if (StringUtils.isEmpty(hostIp)) {
            logger.error("get host ip failure, maybe invalid network name or bad configuration");
        }

        return hostIp;
    }

    private static String getLinuxHostIpByCmd(String networkName) {
        String localIP = "";
        if (StringUtils.isEmpty(networkName)) {
            networkName = "eth0";
        }

        String getIpCmd = "";

        try {
            getIpCmd = MessageFormat.format("ifconfig {0} | grep \"inet\" | awk ''$1==\"inet\" '{print $2'}''", networkName);
            localIP = ShellUtils.execLinuxCmd(getIpCmd);
            String pattern = "((2(5[0-5]|[0-4]\\d))|[0-1]?\\d{1,2})(\\.((2(5[0-5]|[0-4]\\d))|[0-1]?\\d{1,2})){3}";
            Pattern r = Pattern.compile(pattern);
            Matcher m = r.matcher(localIP);
            if (m.find()) {
                localIP = m.group(0);
            }

            if (logger.isDebugEnabled()) {
                logger.debug("get host ip (linux-{}, by cmd) success: {}", networkName, localIP);
            }
        } catch (Throwable var6) {
            logger.debug("get host ip by cmd failed, getIpCmd: {}, exception: {}", getIpCmd, var6);
        }

        return localIP;
    }

    public static String getHostIp() {
        String localIP = "";

        try {
            Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();

            label47:
            while(true) {
                NetworkInterface networkInterface;
                do {
                    do {
                        do {
                            if (!interfaces.hasMoreElements()) {
                                break label47;
                            }

                            networkInterface = (NetworkInterface)interfaces.nextElement();
                        } while(networkInterface.isLoopback());
                    } while(networkInterface.isVirtual());
                } while(!networkInterface.isUp());

                Enumeration<InetAddress> addresses = networkInterface.getInetAddresses();

                while(addresses.hasMoreElements()) {
                    InetAddress address = (InetAddress)addresses.nextElement();
                    localIP = address.getHostAddress();
                    Matcher matcher = Pattern.compile("([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}").matcher(localIP);
                    if (matcher.matches()) {
                        break label47;
                    }
                }
            }
        } catch (SocketException var6) {
            logger.error("get host ip (linux, by NetworkInterface) failed, exception: {}", var6);
        }

        if (logger.isDebugEnabled()) {
            logger.debug("get host ip (linux, by NetworkInterface) success: {}", localIP);
        }

        return localIP;
    }

    public static String getHostIpByConfig() {
        String result = null;

        try {
            if (FileUtil.exist("/etc/network/default_gw")) {
                String text = FileUtil.readString("/etc/network/default_gw", "UTF-8");
                if (StringUtils.isEmpty(text)) {
                    return "";
                }

                String[] strs = text.split("=");
                if (strs != null && strs.length > 1) {
                    String networkName = strs[1].trim();
                    result = getLinuxHostIpByCmd(networkName);
                }
            }
        } catch (Exception var4) {
            logger.error("getHostIpByConfig failed, exception: {}", var4);
        }

        return result;
    }

    public static List<String> getAvailableHostIpList() {
        List<String> ipList = new ArrayList();

        try {
            Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();

            label47:
            while(true) {
                NetworkInterface networkInterface;
                do {
                    do {
                        do {
                            if (!interfaces.hasMoreElements()) {
                                break label47;
                            }

                            networkInterface = (NetworkInterface)interfaces.nextElement();
                        } while(networkInterface.isLoopback());
                    } while(networkInterface.isVirtual());
                } while(!networkInterface.isUp());

                Enumeration<InetAddress> addresses = networkInterface.getInetAddresses();

                while(addresses.hasMoreElements()) {
                    InetAddress address = (InetAddress)addresses.nextElement();
                    String ipString = address.getHostAddress();
                    Matcher matcher = Pattern.compile("([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}").matcher(ipString);
                    if (matcher.matches()) {
                        ipList.add(ipString);
                    }
                }
            }
        } catch (SocketException var7) {
            logger.error("get host ip (linux, by NetworkInterface) failed, exception: {}", var7);
        }

        if (logger.isDebugEnabled()) {
            logger.debug("get host ip (linux, by NetworkInterface) success: {}", JSON.toJSONString(ipList));
        }

        return ipList;
    }

    public static String getHostMac(String ip) {
        String macAddress = "";

        try {
            if (StringUtils.isEmpty(ip) || "127.0.0.1".equals(ip)) {
                ip = getHostIp();
            }

            if (StringUtils.isEmpty(ip)) {
                return "";
            }

            NetworkInterface networkInterface = NetworkInterface.getByInetAddress(InetAddress.getByName(ip));
            if (networkInterface == null) {
                return "";
            }

            byte[] macBytes = networkInterface.getHardwareAddress();
            if (macBytes == null) {
                return "";
            }

            StringBuffer macBuffer = new StringBuffer("");

            for(int i = 0; i < macBytes.length; ++i) {
                if (i > 0) {
                    macBuffer.append("-");
                }

                int temp = macBytes[i] & 255;
                String str = Integer.toHexString(temp);
                if (str.length() == 1) {
                    macBuffer.append("0" + str);
                } else {
                    macBuffer.append(str);
                }
            }

            macAddress = macBuffer.toString().toUpperCase();
        } catch (UnknownHostException | SocketException var8) {
            logger.error("get host mac (linux, by NetworkInterface) failed, exception: {}", var8);
        }

        if (logger.isDebugEnabled()) {
        }

        return macAddress;
    }

    public static String getRemoteHost(HttpServletRequest request) {
        String ip = request.getHeader("x-real-ip");
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("X-Real-IP");
            if (logger.isDebugEnabled()) {
                logger.debug("get client ip from header X-Real-IP is: {}", ip);
            }
        }

        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("X-Forwarded-For");
            if (ip != null && ip.length() != 0 && ip.indexOf(",") != -1) {
                ip = ip.split(",")[0];
            }
        }

        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;
    }

    public static boolean isReachable(String ip) {
        boolean flag = false;

        try {
            InetAddress address = InetAddress.getByName(ip);
            flag = address.isReachable(3000);
            if (logger.isDebugEnabled()) {
                logger.debug("addr :" + ip + ", isReachable:" + flag);
            }
        } catch (Exception var3) {
            logger.debug("Unknown host " + ip);
        }

        return flag;
    }

    public static boolean isReachable(String ip, String port) {
        boolean flag = false;
        Socket socket = null;

        try {
            socket = new Socket(ip, Integer.parseInt(port));
            if (logger.isDebugEnabled()) {
                logger.debug("addr :" + ip + ", isReachable:" + flag);
            }

            flag = true;
        } catch (Exception var13) {
            logger.debug("Unknown host : " + ip + ":" + port);
        } finally {
            try {
                if (socket != null) {
                    socket.close();
                }
            } catch (IOException var12) {
                logger.error(var12.getMessage(), var12);
            }

        }

        return flag;
    }

    public static String toIpNumberStr(String ip) {
        String result = null;
        if (!StringUtils.isEmpty(ip)) {
            StringBuilder ipNumStrBuilder = new StringBuilder();
            String[] ipSegments = ip.split("\\.");
            Format decimalFormat = new DecimalFormat("000");

            try {
                String[] var5 = ipSegments;
                int var6 = ipSegments.length;

                for(int var7 = 0; var7 < var6; ++var7) {
                    String ipSeg = var5[var7];
                    Integer ipSegInt = Integer.valueOf(ipSeg);
                    ipNumStrBuilder.append(decimalFormat.format(ipSegInt));
                }
            } catch (Exception var10) {
            }

            result = ipNumStrBuilder.toString();
        }

        return result;
    }

    public static long convert2Long(String ip) {
        long result = 0L;
        Matcher matcher = Pattern.compile("([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}").matcher(ip);
        if (matcher.matches()) {
            String[] ipSegments = ip.split("\\.");

            for(int i = 0; i < ipSegments.length; ++i) {
                long segValue = Long.parseLong(ipSegments[i]);
                result = (long)((double)result + (double)segValue * Math.pow(256.0, (double)i));
            }
        }

        return result;
    }

    public static String convert2Ip(long value) {
        StringBuilder result = new StringBuilder(15);

        for(int i = 0; i < 4; ++i) {
            result.append(Long.toString(value & 255L));
            if (i < 3) {
                result.append(".");
            }

            value >>= 8;
        }

        return result.toString();
    }

    public static String convert2Hex(String ip, boolean isLowerCase, Integer fixedLength) {
        String hexResultString = "";
        fixedLength = fixedLength == null ? 8 : fixedLength;
        long longValue = convert2Long(ip);
        String hexString = Long.toHexString(longValue);
        if (!StringUtils.isEmpty(hexString) && hexString.length() < fixedLength) {
            while(hexString.length() < 8) {
                hexString = "0" + hexString;
            }
        }

        if (isLowerCase) {
            hexResultString = hexString.toLowerCase();
        } else {
            hexResultString = hexString.toUpperCase();
        }

        return hexResultString;
    }

    public static String convert2Ip(String stringHex) {
        String regex = "^[A-Fa-f0-9]{1,8}$";
        if (!stringHex.matches(regex)) {
            return "";
        } else {
            long value = Long.parseLong(stringHex, 16);
            return convert2Ip(value);
        }
    }
	public static String getLinuxLocalIp() {
		String ip = "";
		try {
			for (Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces(); en.hasMoreElements(); ) {
				NetworkInterface intf = en.nextElement();
				String name = intf.getName();
				if (!name.contains("docker") && !name.contains("lo")) {
					for (Enumeration<InetAddress> enumIpAddr = intf.getInetAddresses(); enumIpAddr.hasMoreElements(); ) {
						InetAddress inetAddress = enumIpAddr.nextElement();
						if (!inetAddress.isLoopbackAddress()) {
							String ipaddress = inetAddress.getHostAddress().toString();
							if (!ipaddress.contains("::") && !ipaddress.contains("0:0:") && !ipaddress.contains("fe80")) {
								ip = ipaddress;
							}
						}
					}
				}
			}
		} catch (SocketException ex) {
			ip = "127.0.0.1";
			ex.printStackTrace();
		}
		return ip;
	}

}

johnrui
关注
IpUtils 获取ip 工具类 java
global_coding的博客
06-06 739
IpUtils 获取ip 工具类 java
IPUtils 获取IP工具类
zhangfeiyue12178的博客
03-29 994
IPUtils 获取IP工具类 import lombok.extern.log4j.Log4j2; import org.apache.commons.lang.StringUtils; import javax.servlet.http.HttpServletRequest; import java.net.Inet4Address; import java.net.InetAddress; import java.net.NetworkInterface; import java.net.S.
服务器信息获取
Living_and_learning的博客
10-29 347
import javax.servlet.http.HttpServletRequest; import java.net.InetAddress; public class IpUtils { /** * 获取本机ip * * @return */ public static String getIp() { Stri...
IpUtils工具类
黑科技的专栏
11-02 696
IpUtils工具类
ip相关工具类
小李同学的博客
02-21 932
ip相关工具类
ip工具类（用于判断IP是否在网段内，给定网段判断IP的范围）
05-20
ip工具类（用于判断IP是否在网段内，给定网段判断IP的范围）
java工具类（包括bean操作工具类、浏览器读取工具累、汉字转拼音工具类、图片处理工具类、ip工具类、随机码工具类、json）
07-27
java工具类（包括bean操作工具类、浏览器读取工具累、汉字转拼音工具类、图片处理工具类、ip工具类、随机码工具类、json）
20230619获取ip工具类
06-19
20230619获取ip工具类
IpUtil工具类--通过request获取IP，通过IP获取地址
11-30
IpUtil工具类--通过request获取IP，通过IP获取地址(需要联网，调用淘宝的IP库)。使用场景：在网站开发记录用户增删改查日志的时候，往往需要记录操作人的IP地址，来准确的生成操作日志记录等
获取Ip地址的Java工具类
04-02
通过该工具类可以获得请求的IP地址，适用于后台管理系统的信息统计。
java获取IP地址工具类
03-31
利用淘宝IP地址库实现的利用IP获取用户所在地工具类
java的ip常用工具类
08-17
此工具类包含根据ip和掩码(cidr)计算网段 判断ip是否在网段内 判断是否是ip ip转long long类型的ip转string
java 测试ip是否畅通的工具类
08-19
通过java 验证机器与某ip地址能否联通的工具类。配置ip地址就可以测试使用了。
JAVA代码优化：IP地址获取的工具类
码字码字码字
12-01 1226
该工具类主要用于从HttpServletRequest对象中获取客户端IP地址，并提供了判断IP地址是否为内部IP地址的功能。另外，还提供了获取本机IP地址和主机名的方法。用于获取客户端IP地址的工具类。代码中定义了一个名为。
Java IP地址计算工具类
qq_40563534的博客
06-13 900
掩码长度mask转子网掩码 计算可用IP
深入理解iputils网络工具-第2篇 ping：通路检测程序
热门推荐
李希的博客
08-14 1万+
2.1       引言    “ping”这个名字源于声纳定位操作。Ping程序由Mike Muuss编写，目的是为了测试另一台主机是否可达。该程序发送一份ICMP回显请求报文给主机，并等待返回ICMP回显应答。 2.2       ping程序的使用     敲入命令： lixi@lixi-desktop:~$ ping -V ping utility, iputils-sss2007
java工具类之 IP工具类
最新发布
优快云博客技术，java高级工程师，业务层架构师，高级管理认证，毕业设计可以联系我
02-18 273
【代码】java工具类之 IP工具类。
获取ip工具类
duanhaiyang1的博客
06-25 281
【代码】获取ip工具类。
Java处理IP工具类：转换与掩码操作
"Java基础之处理IP的工具类，提供了将long类型IP转换为普通字符串IP，以及将字符串IP转换为long类型，还包括了根据掩码计算IP段的方法。" 在Java开发中，处理IP地址是一项常见的任务，尤其是在网络编程和数据分析中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值