com.redismq.common.util.NetUtil Maven / Gradle / Ivy
package com.redismq.common.util;
import io.netty.channel.Channel;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.NetworkInterface;
import java.net.SocketAddress;
import java.net.UnknownHostException;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.regex.Pattern;
/**
* The type Net util.
*
* @author slievrly
*/
public class NetUtil {
private static final Logger LOGGER = LoggerFactory.getLogger(NetUtil.class);
private static final String LOCALHOST = "127.0.0.1";
private static final String ANY_HOST = "0.0.0.0";
private static volatile InetAddress LOCAL_ADDRESS = null;
private static final Pattern IP_PATTERN = Pattern.compile("\\d{1,3}(\\.\\d{1,3}){3,5}$");
/**
* To string address string.
*
* @param address the address
* @return the string
*/
public static String toStringAddress(SocketAddress address) {
if (address == null) {
return StringUtils.EMPTY;
}
return toStringAddress((InetSocketAddress) address);
}
/**
* To ip address string.
*
* @param address the address
* @return the string
*/
public static String toIpAddress(SocketAddress address) {
InetSocketAddress inetSocketAddress = (InetSocketAddress) address;
return inetSocketAddress.getAddress().getHostAddress();
}
/**
* To string address string.
*
* @param address the address
* @return the string
*/
public static String toStringAddress(InetSocketAddress address) {
return address.getAddress().getHostAddress() + ":" + address.getPort();
}
/**
* To inet socket address inet socket address.
*
* @param address the address
* @return the inet socket address
*/
public static InetSocketAddress toInetSocketAddress(String address) {
int i = address.indexOf(':');
String host;
int port;
if (i > -1) {
host = address.substring(0, i);
port = Integer.parseInt(address.substring(i + 1));
} else {
host = address;
port = 0;
}
return new InetSocketAddress(host, port);
}
/**
* To long long.
*
* @param address the address
* @return the long
*/
public static long toLong(String address) {
InetSocketAddress ad = toInetSocketAddress(address);
String[] ip = ad.getAddress().getHostAddress().split("\\.");
long r = 0;
r = r | (Long.parseLong(ip[0]) << 40);
r = r | (Long.parseLong(ip[1]) << 32);
r = r | (Long.parseLong(ip[2]) << 24);
r = r | (Long.parseLong(ip[3]) << 16);
r = r | ad.getPort();
return r;
}
/**
* Gets local ip.
*
* @return the local ip
*/
public static String getLocalIp(String... preferredNetworks) {
InetAddress address = getLocalAddress(preferredNetworks);
return address == null ? LOCALHOST : address.getHostAddress();
}
public static String getAddressFromChannel(Channel channel) {
SocketAddress socketAddress = channel.remoteAddress();
String address = socketAddress.toString();
if (socketAddress.toString().indexOf("/") == 0) {
address = socketAddress.toString().substring("/".length());
}
return address;
}
public static void main(String[] args) {
String localHost = getLocalHost();
System.out.println(localHost);
}
/**
* Gets local host.
*
* @return the local host
*/
public static String getLocalHost() {
InetAddress address = getLocalAddress();
return address == null ? "localhost" : address.getHostName();
}
/**
* Gets local address.
* not support ipv6
* if match the preferredNetworks rule return the first
* if all not match preferredNetworks rule return the first valid ip
* @return the local address
*/
public static InetAddress getLocalAddress(String... preferredNetworks) {
if (LOCAL_ADDRESS != null) {
return LOCAL_ADDRESS;
}
InetAddress localAddress = getLocalAddress0(preferredNetworks);
LOCAL_ADDRESS = localAddress;
return localAddress;
}
private static InetAddress getLocalAddress0(String... preferredNetworks) {
InetAddress localAddress = null;
try {
Enumeration interfaces = NetworkInterface.getNetworkInterfaces();
if (interfaces != null) {
while (interfaces.hasMoreElements()) {
try {
NetworkInterface network = interfaces.nextElement();
if (network.isUp()) {
Enumeration addresses = network.getInetAddresses();
while (addresses.hasMoreElements()) {
try {
InetAddress address = addresses.nextElement();
if (isValidAddress(address)) {
if (null == localAddress) {
localAddress = address;
}
//check preferredNetworks
if (preferredNetworks.length > 0) {
String ip = address.getHostAddress();
for (String regex : preferredNetworks) {
if (StringUtils.isBlank(regex)) {
continue;
}
if (ip.matches(regex) || ip.startsWith(regex)) {
return address;
}
}
} else {
return address;
}
}
} catch (Throwable e) {
LOGGER.warn("Failed to retrieving ip address, {}", e.getMessage(), e);
}
}
}
} catch (Throwable e) {
LOGGER.warn("Failed to retrieving ip address, {}", e.getMessage(), e);
}
}
}
} catch (Throwable e) {
LOGGER.warn("Failed to retrieving ip address, {}", e.getMessage(), e);
}
if (localAddress == null) {
LOGGER.error("Could not get local host ip address, will use 127.0.0.1 instead.");
} else {
LOGGER.error("Could not match ip by preferredNetworks:{}, will use default first ip {} instead.", Arrays.toString(preferredNetworks), localAddress.getHostAddress());
}
return localAddress;
}
/**
* Valid address.
*
* @param address the address
*/
public static void validAddress(InetSocketAddress address) {
if (address.getHostName() == null || 0 == address.getPort()) {
throw new IllegalArgumentException("invalid address:" + address);
}
}
/**
* is valid address
*
* @param address
* @return true if the given address is valid
*/
private static boolean isValidAddress(InetAddress address) {
if (address == null || address.isLoopbackAddress()) {
return false;
}
return isValidIp(address.getHostAddress(), false);
}
/**
* is valid IP
*
* @param ip
* @param validLocalAndAny Are 127.0.0.1 and 0.0.0.0 valid IPs?
* @return true if the given IP is valid
*/
public static boolean isValidIp(String ip, boolean validLocalAndAny) {
if (ip == null) {
return false;
}
ip = convertIpIfNecessary(ip);
if (validLocalAndAny) {
return IP_PATTERN.matcher(ip).matches();
} else {
return !ANY_HOST.equals(ip) && !LOCALHOST.equals(ip) && IP_PATTERN.matcher(ip).matches();
}
}
/**
* convert ip if necessary
*
* @param ip
* @return java.lang.String
*/
private static String convertIpIfNecessary(String ip) {
if (IP_PATTERN.matcher(ip).matches()) {
return ip;
} else {
try {
return InetAddress.getByName(ip).getHostAddress();
} catch (UnknownHostException e) {
throw new RuntimeException(e);
}
}
}
}