InetAddress

java.net.InetAddress类是Java对IP地址（包括IPv4和IPv6）的高层表示。大多数其他网络类都要用到这个类，包括Socket，ServerSocket，URL，DatagramSocket，DatagramPacket等。一般地讲，它包括一个主机名和一个IP地址。

一、主机名解析
主机名到 IP 地址的解析 通过使用本地机器配置信息和网络命名服务（如域名系统（Domain Name System，DNS）和网络信息服务（Network Information Service，NIS））来实现。
反向名称解析 意味着对于任何 IP 地址，都返回与 IP 地址关联的主机。 
InetAddress 类提供将主机名解析为其 IP 地址（或反之）的方法。 

static InetAddress[] getAllByName(String host)   在给定主机名的情况下，根据系统上配置的名称服务返回所有的 IP 地址。static InetAddress getByAddress(byte[] addr)   在给定原始 IP 地址的情况下，返回 InetAddress 对象。 static InetAddress getByAddress(String host, byte[] addr)   根据提供的主机名和 IP 地址创建 InetAddress。 static InetAddress getByName(String host)   在给定主机名的情况下确定主机的 IP 地址。 String getCanonicalHostName()   获取此 IP 地址的完全限定域名。 String getHostAddress()   返回 IP 地址字符串，比如192.168.1.1 String getHostName()   获取此 IP 地址的主机名。 比如www.baidu.comstatic InetAddress getLocalHost()   返回本地主机。 boolean isReachable(int timeout)   测试是否可以达到该地址。 

二、InetAddress 缓存
对于相同的域名查找，InetAddress 类具有一个缓存，用于存储成功及不成功的主机名解析。

默认情况下，如果安装了安全管理器(security manager)，为了防止DNS欺骗攻击，会永久缓存正确的域名解析。
如果没有安装安全管理器，默认行为将缓存一段有限（与实现相关）时间，不成功主机名解析的结果缓存非常短的时间（10 秒）以提高性能。 

如果不需要默认行为，则可以将 Java 安全属性设置为另外的 Time-to-live (TTL) 值来进行缓存。
两个 Java 安全属性控制着用于正负主机名解析缓存的 TTL 值： 
networkaddress.cache.ttl
  用来设置正确的域名解析缓存时间，单位：秒， -1表示“cache forever”
networkaddress.cache.negative.ttl (default: 10)
  用来设置错误的域名解析缓存时间，单位：秒，-1表示“cache forever”，0表示“never cache”

我们来看看InetAddress缓存策略

/*** InetAddress缓存策略*/public final class InetAddressCachePolicy {    private static final String cachePolicyProp = "networkaddress.cache.ttl";    private static final String cachePolicyPropFallback = "sun.net.inetaddr.ttl";    private static final String negativeCachePolicyProp = "networkaddress.cache.negative.ttl";    private static final String negativeCachePolicyPropFallback = "sun.net.inetaddr.negative.ttl";    public static final int FOREVER = -1;    public static final int NEVER = 0;    public static final int DEFAULT_POSITIVE = 30; //正确解析 默认30秒    private static int cachePolicy = -1;    private static int negativeCachePolicy = 0; //错误解析，默认“never cache”    private static boolean propertySet;  //是否设置了正确解析的缓存时间    private static boolean propertyNegativeSet; //是否设置了错误解析的缓存时间    public InetAddressCachePolicy() {    }//正确解析的缓存时间    public static synchronized int get() {        return cachePolicy;    }//错误解析的缓存时间    public static synchronized int getNegative() {        return negativeCachePolicy;    }    public static synchronized void setIfNotSet(int var0) {        if(!propertySet) {            checkValue(var0, cachePolicy);            cachePolicy = var0;        }    }    public static synchronized void setNegativeIfNotSet(int var0) {        if(!propertyNegativeSet) {            negativeCachePolicy = var0;        }    }    private static void checkValue(int var0, int var1) {        if(var0 != -1) {            if(var1 == -1 || var0 < var1 || var0 < -1) {                throw new SecurityException("can\'t make InetAddress cache more lax");            }        }    }    static {//获取解析成功的缓存时间        Integer var0 = (Integer)AccessController.doPrivileged(new PrivilegedAction() {            public Integer run() {                String var1;                try {                    var1 = Security.getProperty("networkaddress.cache.ttl");                    if(var1 != null) {                        return Integer.valueOf(var1);                    }                } catch (NumberFormatException var3) {                    ;                }                try {                    var1 = System.getProperty("sun.net.inetaddr.ttl");                    if(var1 != null) {                        return Integer.decode(var1);                    }                } catch (NumberFormatException var2) {                    ;                }                return null;            }        });        if(var0 != null) {            cachePolicy = var0.intValue();            if(cachePolicy < 0) {                cachePolicy = -1;            }            propertySet = true;        } else if(System.getSecurityManager() == null) {            cachePolicy = 30;        }        var0 = (Integer)AccessController.doPrivileged(new PrivilegedAction() {            public Integer run() {                String var1;                try {                    var1 = Security.getProperty("networkaddress.cache.negative.ttl");//默认10秒                    if(var1 != null) {                        return Integer.valueOf(var1);                    }                } catch (NumberFormatException var3) {                    ;                }                try {                    var1 = System.getProperty("sun.net.inetaddr.negative.ttl");                    if(var1 != null) {                        return Integer.decode(var1);                    }                } catch (NumberFormatException var2) {                    ;                }                return null;            }        });        if(var0 != null) {            negativeCachePolicy = var0.intValue();            if(negativeCachePolicy < 0) {                negativeCachePolicy = -1;            }            propertyNegativeSet = true;        }    }}

三、InetAddressImpl

InetAddress实现有Inet4AddressImpl和Inet6AddressImpl

public class Inet4AddressImpl implements InetAddressImpl{    public native String getLocalHostName() throws UnknownHostException;    public native java.net.InetAddress[]    lookupAllHostAddr(String hostname) throws UnknownHostException;    public native String getHostByAddr(byte[] addr) throws UnknownHostException;    private native boolean isReachable0(byte[] addr, int timeout, byte[] ifaddr, int ttl) throws IOException;    /**     * 返回  0.0.0.0/0.0.0.0     */    public synchronized java.net.InetAddress anyLocalAddress() {        if (anyLocalAddress == null) {            anyLocalAddress = new Inet4Address(); // {0x00,0x00,0x00,0x00}            anyLocalAddress.holder().hostName = "0.0.0.0";        }        return anyLocalAddress;    }    /**     * 返回  localhost/127.0.0.1     */    public synchronized java.net.InetAddress loopbackAddress() {        if (loopbackAddress == null) {            byte[] loopback = {0x7f,0x00,0x00,0x01}; //127.0.0.1            loopbackAddress = new Inet4Address("localhost", loopback);        }        return loopbackAddress;    }    public boolean isReachable(java.net.InetAddress addr, int timeout, NetworkInterface netif, int ttl) throws IOException {        byte[] ifaddr = null;        if (netif != null) {          /*           * Let's make sure we use an address of the proper family           */            java.util.Enumeration<java.net.InetAddress> it = netif.getInetAddresses();            java.net.InetAddress inetaddr = null;            while (!(inetaddr instanceof Inet4Address) &&                    it.hasMoreElements())                inetaddr = it.nextElement();            if (inetaddr instanceof Inet4Address)                ifaddr = inetaddr.getAddress();        }        return isReachable0(addr.getAddress(), timeout, ifaddr, ttl);    }    private java.net.InetAddress anyLocalAddress;    private java.net.InetAddress loopbackAddress;}

四、InetAddress源码

 class InetAddress implements java.io.Serializable {    static final int IPv4 = 1;    static final int IPv6 = 2;    static transient boolean preferIPv6Address = false;    static class InetAddressHolder {        String originalHostName;        InetAddressHolder() {}        InetAddressHolder(String hostName, int address, int family) {            this.originalHostName = hostName;            this.hostName = hostName;            this.address = address;            this.family = family;        }        void init(String hostName, int family) {            this.originalHostName = hostName;            this.hostName = hostName;            if (family != -1) {                this.family = family;            }        }        String hostName;        String getHostName() {            return hostName;        }        String getOriginalHostName() {            return originalHostName;        }        /**         * Holds a 32-bit IPv4 address.         */        int address;        int getAddress() {            return address;        }        int family; //IPv4=1,IPv6=2        int getFamily() {            return family;        }    }    /* Used to store the serializable fields of InetAddress */    final transient java.net.InetAddress.InetAddressHolder holder;    java.net.InetAddress.InetAddressHolder holder() {        return holder;    }    /* Used to store the name service provider */    private static List<NameService> nameServices = null;    /* Used to store the best available hostname */    private transient String canonicalHostName = null;    /** use serialVersionUID from JDK 1.0.2 for interoperability */    private static final long serialVersionUID = 3286316764910316507L;    /*     * Load net library into runtime, and perform initializations.     */    static {        preferIPv6Address = java.security.AccessController.doPrivileged(                new GetBooleanAction("java.net.preferIPv6Addresses")).booleanValue();        AccessController.doPrivileged(                new java.security.PrivilegedAction<Void>() {                    public Void run() {                        System.loadLibrary("net");                        return null;                    }                });        init();    }    InetAddress() {        holder = new java.net.InetAddress.InetAddressHolder();    }    private Object readResolve() throws ObjectStreamException {        // will replace the deserialized 'this' object        return new Inet4Address(holder().getHostName(), holder().getAddress());    }    public boolean isMulticastAddress() {        return false;    }    public boolean isAnyLocalAddress() {        return false;    }    public boolean isLoopbackAddress() {        return false;    }    public boolean isLinkLocalAddress() {        return false;    }    public boolean isSiteLocalAddress() {        return false;    }    public boolean isMCGlobal() {        return false;    }    public boolean isMCNodeLocal() {        return false;    }    public boolean isMCLinkLocal() {        return false;    }    public boolean isMCSiteLocal() {        return false;    }    public boolean isMCOrgLocal() {        return false;    }    public boolean isReachable(int timeout) throws IOException {        return isReachable(null, 0 , timeout);    }    /**     *  测试是否可以达到该地址。     *  实现尽最大努力试图到达主机，但防火墙和服务器配置可能阻塞请求，使其在某些特定的端口可以访问时处于不可到达状态。     * @param   netif   用于完成测试的 NetworkInterface；或者用于任何接口的 null     * @param   ttl     要尝试的最大跳数或默认值 0     * @param   timeout 调用中止前的时间（以毫秒为单位）     */    public boolean isReachable(NetworkInterface netif, int ttl,                               int timeout) throws IOException {        if (ttl < 0)            throw new IllegalArgumentException("ttl can't be negative");        if (timeout < 0)            throw new IllegalArgumentException("timeout can't be negative");        return impl.isReachable(this, timeout, netif, ttl);    }    /**     * 获取此 IP 地址的主机名。     * 如果此 InetAddress 是用host name创建的，则记忆并返回主机名；     * 否则，将执行反向名称查找并基于系统配置的名称查找服务返回结果。     * 如果需要查找名称服务，则调用 getCanonicalHostName。     * 如果有安全管理器，则首先使用host name和 -1 作为参数来调用其 checkConnect 方法，     * 以查看是否允许该操作。如果不允许该操作，则其返回 IP 地址的文本表示形式。     *     * @return  此 IP 地址的主机名；如果安全检查不允许操作，则返回 IP 地址的文本表示形式。     *     * @see java.net.InetAddress#getCanonicalHostName     * @see SecurityManager#checkConnect     */    public String getHostName() {        return getHostName(true);    }    String getHostName(boolean check) {        //如果hostName=null，则查找并缓存hostName        if (holder().getHostName() == null) {            holder().hostName = java.net.InetAddress.getHostFromNameService(this, check);        }        return holder().getHostName();    }    /**     * 获取此 IP 地址的完全限定域名。根据底层系统配置可能不能返回 FQDN。     */    public String getCanonicalHostName() {        //canonicalHostName=null，则查找并缓存canonicalHostName        if (canonicalHostName == null) {            canonicalHostName =                    java.net.InetAddress.getHostFromNameService(this, true);        }        return canonicalHostName;    }    private static String getHostFromNameService(java.net.InetAddress addr, boolean check) {        String host = null;        for (NameService nameService : nameServices) {            try {                // first lookup the hostname                host = nameService.getHostByAddr(addr.getAddress());                /* check to see if calling code is allowed to know                 * the hostname for this IP address, ie, connect to the host                 */                if (check) {                    SecurityManager sec = System.getSecurityManager();                    if (sec != null) {                        sec.checkConnect(host, -1);                    }                }                /* now get all the IP addresses for this hostname,                 * and make sure one of them matches the original IP                 * address. We do this to try and prevent spoofing.                 */                java.net.InetAddress[] arr = java.net.InetAddress.getAllByName0(host, check);                boolean ok = false;                if(arr != null) {                    for(int i = 0; !ok && i < arr.length; i++) {                        ok = addr.equals(arr[i]);                    }                }                //XXX: if it looks a spoof just return the address?                if (!ok) {                    host = addr.getHostAddress();                    return host;                }                break;            } catch (SecurityException e) {                host = addr.getHostAddress();                break;            } catch (UnknownHostException e) {                host = addr.getHostAddress();                // let next provider resolve the hostname            }        }        return host;    }    /**     * Returns the raw IP address of this {@code InetAddress}     * object. The result is in network byte order: the highest order     * byte of the address is in {@code getAddress()[0]}.     *     * @return  the raw IP address of this object.     */    public byte[] getAddress() {        return null;    }    public String getHostAddress() {        return null;    }    public int hashCode() {        return -1;    }    public boolean equals(Object obj) {        return false;    }    public String toString() {        String hostName = holder().getHostName();        return ((hostName != null) ? hostName : "")                + "/" + getHostAddress();    }    //成功解析的缓存    private static java.net.InetAddress.Cache addressCache = new java.net.InetAddress.Cache(java.net.InetAddress.Cache.Type.Positive);    //失败解析的缓存    private static java.net.InetAddress.Cache negativeCache = new java.net.InetAddress.Cache(java.net.InetAddress.Cache.Type.Negative);    private static boolean addressCacheInit = false;    static java.net.InetAddress[]    unknown_array; // put THIS in cache    static InetAddressImpl impl;    private static final HashMap<String, Void> lookupTable = new HashMap<>();    /**     * Represents a cache entry     */    static final class CacheEntry {        CacheEntry(java.net.InetAddress[] addresses, long expiration) {            this.addresses = addresses;            this.expiration = expiration;        }        java.net.InetAddress[] addresses;        long expiration;    }    /**     * A cache that manages entries based on a policy specified     * at creation time.     */    static final class Cache {        private LinkedHashMap<String, java.net.InetAddress.CacheEntry> cache;        private java.net.InetAddress.Cache.Type type;        enum Type {Positive, Negative};        /**         * Create cache         */        public Cache(java.net.InetAddress.Cache.Type type) {            this.type = type;            cache = new LinkedHashMap<String, java.net.InetAddress.CacheEntry>();        }        private int getPolicy() {            if (type == java.net.InetAddress.Cache.Type.Positive) {                return InetAddressCachePolicy.get();            } else {                return InetAddressCachePolicy.getNegative();            }        }        /**         * Add an entry to the cache. If there's already an         * entry then for this host then the entry will be         * replaced.         */        public java.net.InetAddress.Cache put(String host, java.net.InetAddress[] addresses) {            int policy = getPolicy();            if (policy == InetAddressCachePolicy.NEVER) {                return this;            }            // purge any expired entries            if (policy != InetAddressCachePolicy.FOREVER) {                // As we iterate in insertion order we can                // terminate when a non-expired entry is found.                LinkedList<String> expired = new LinkedList<>();                long now = System.currentTimeMillis();                for (String key : cache.keySet()) {                    java.net.InetAddress.CacheEntry entry = cache.get(key);                    if (entry.expiration >= 0 && entry.expiration < now) {                        expired.add(key);                    } else {                        break;                    }                }                for (String key : expired) {                    cache.remove(key);                }            }            // create new entry and add it to the cache            // -- as a HashMap replaces existing entries we            //    don't need to explicitly check if there is            //    already an entry for this host.            long expiration;            if (policy == InetAddressCachePolicy.FOREVER) {                expiration = -1;            } else {                expiration = System.currentTimeMillis() + (policy * 1000);            }            java.net.InetAddress.CacheEntry entry = new java.net.InetAddress.CacheEntry(addresses, expiration);            cache.put(host, entry);            return this;        }        /**         * Query the cache for the specific host. If found then         * return its CacheEntry, or null if not found.         */        public java.net.InetAddress.CacheEntry get(String host) {            int policy = getPolicy();            if (policy == InetAddressCachePolicy.NEVER) {                return null;            }            java.net.InetAddress.CacheEntry entry = cache.get(host);            // check if entry has expired            if (entry != null && policy != InetAddressCachePolicy.FOREVER) {                if (entry.expiration >= 0 &&                        entry.expiration < System.currentTimeMillis()) {                    cache.remove(host);                    entry = null;                }            }            return entry;        }    }    /**     * 初始化缓存     */    private static void cacheInitIfNeeded() {        assert Thread.holdsLock(addressCache);        if (addressCacheInit) {            //如果已初始化缓存，则直接返回            return;        }        unknown_array = new java.net.InetAddress[1];        unknown_array[0] = impl.anyLocalAddress(); // 0.0.0.0/0.0.0.0         // 0.0.0.0 <->unknown_array        addressCache.put(impl.anyLocalAddress().getHostName(),                unknown_array);        addressCacheInit = true;    }    /**     * 添加缓存     */    private static void cacheAddresses(String hostname,                                       java.net.InetAddress[] addresses,                                       boolean success) {        hostname = hostname.toLowerCase();        synchronized (addressCache) {            cacheInitIfNeeded();            if (success) { //成功解析                addressCache.put(hostname, addresses);            } else { //失败解析                negativeCache.put(hostname, addresses);            }        }    }    /**     * 获取缓存     */    private static java.net.InetAddress[] getCachedAddresses(String hostname) {        hostname = hostname.toLowerCase();        // 同时查找成功和失败的解析缓存        synchronized (addressCache) {            cacheInitIfNeeded();             //先查找成功解析的缓存            java.net.InetAddress.CacheEntry entry = addressCache.get(hostname);            if (entry == null) {                //再查找失败解析的缓存                entry = negativeCache.get(hostname);            }            if (entry != null) {                return entry.addresses;            }        }        return null;    }    //创建NameServiceProvider    private static NameService createNSProvider(String provider) {        if (provider == null)            return null;        NameService nameService = null;        if (provider.equals("default")) {            // initialize the default name service            nameService = new NameService() {                public java.net.InetAddress[] lookupAllHostAddr(String host)                        throws UnknownHostException {                    //根据host查找ip                    return impl.lookupAllHostAddr(host);                }                public String getHostByAddr(byte[] addr)                        throws UnknownHostException {                    //根据ip查找host                    return impl.getHostByAddr(addr);                }            };        } else {            final String providerName = provider;            try {                nameService = java.security.AccessController.doPrivileged(                        new java.security.PrivilegedExceptionAction<NameService>() {                            public NameService run() {                                Iterator<NameServiceDescriptor> itr =                                        ServiceLoader.load(NameServiceDescriptor.class)                                                .iterator();                                while (itr.hasNext()) {                                    NameServiceDescriptor nsd = itr.next();                                    if (providerName.                                            equalsIgnoreCase(nsd.getType()+","                                                    +nsd.getProviderName())) {                                        try {                                            return nsd.createNameService();                                        } catch (Exception e) {                                            e.printStackTrace();                                            System.err.println(                                                    "Cannot create name service:"                                                            +providerName+": " + e);                                        }                                    }                                }                                return null;                            }                        }                );            } catch (java.security.PrivilegedActionException e) {            }        }        return nameService;    }    /**     * 静态初始化     */    static {        // 创建InetAddress实现，Inet4AddressImpl还是Inet6AddressImpl        impl = java.net.InetAddressImplFactory.create();        // get name service if provided and requested        String provider = null;;        String propPrefix = "sun.net.spi.nameservice.provider.";        int n = 1;        nameServices = new ArrayList<NameService>();        provider = AccessController.doPrivileged(                new GetPropertyAction(propPrefix + n));        // provider = System.getProperty(propPrefix + n);        while (provider != null) {            NameService ns = createNSProvider(provider);            if (ns != null)                nameServices.add(ns);            n++;            provider = AccessController.doPrivileged(                    new GetPropertyAction(propPrefix + n));        }        // if not designate any name services provider,        // create a default one        if (nameServices.size() == 0) {            NameService ns = createNSProvider("default");            nameServices.add(ns);        }    }    public static java.net.InetAddress getByAddress(String host, byte[] addr)            throws UnknownHostException {        if (host != null && host.length() > 0 && host.charAt(0) == '[') {            if (host.charAt(host.length()-1) == ']') {                host = host.substring(1, host.length() -1);            }        }        if (addr != null) {            if (addr.length == Inet4Address.INADDRSZ) {                return new Inet4Address(host, addr);            } else if (addr.length == Inet6Address.INADDRSZ) {                byte[] newAddr                        = IPAddressUtil.convertFromIPv4MappedAddress(addr);                if (newAddr != null) {                    return new Inet4Address(host, newAddr);                } else {                    return new Inet6Address(host, addr);                }            }        }        throw new UnknownHostException("addr is of illegal length");    }    public static java.net.InetAddress getByName(String host)            throws UnknownHostException {        return java.net.InetAddress.getAllByName(host)[0];    }    // called from deployment cache manager    private static java.net.InetAddress getByName(String host, java.net.InetAddress reqAddr)            throws UnknownHostException {        return java.net.InetAddress.getAllByName(host, reqAddr)[0];    }    public static java.net.InetAddress[] getAllByName(String host)            throws UnknownHostException {        return getAllByName(host, null);    }    private static java.net.InetAddress[] getAllByName(String host, java.net.InetAddress reqAddr)            throws UnknownHostException {        if (host == null || host.length() == 0) {            java.net.InetAddress[] ret = new java.net.InetAddress[1];            ret[0] = impl.loopbackAddress(); // localhost/127.0.0.1            return ret;        }        boolean ipv6Expected = false;        if (host.charAt(0) == '[') {            // This is supposed to be an IPv6 literal            if (host.length() > 2 && host.charAt(host.length()-1) == ']') {                host = host.substring(1, host.length() -1);                ipv6Expected = true;            } else {                // This was supposed to be a IPv6 address, but it's not!                throw new UnknownHostException(host + ": invalid IPv6 address");            }        }        // if host is an IP address, we won't do further lookup        if (Character.digit(host.charAt(0), 16) != -1                || (host.charAt(0) == ':')) {            byte[] addr = null;            int numericZone = -1;            String ifname = null;            // see if it is IPv4 address            addr = IPAddressUtil.textToNumericFormatV4(host);            if (addr == null) {                // This is supposed to be an IPv6 literal                // Check if a numeric or string zone id is present                int pos;                if ((pos=host.indexOf ("%")) != -1) {                    numericZone = checkNumericZone (host);                    if (numericZone == -1) { /* remainder of string must be an ifname */                        ifname = host.substring (pos+1);                    }                }                if ((addr = IPAddressUtil.textToNumericFormatV6(host)) == null && host.contains(":")) {                    throw new UnknownHostException(host + ": invalid IPv6 address");                }            } else if (ipv6Expected) {                // Means an IPv4 litteral between brackets!                throw new UnknownHostException("["+host+"]");            }            java.net.InetAddress[] ret = new java.net.InetAddress[1];            if(addr != null) {                if (addr.length == Inet4Address.INADDRSZ) {                    ret[0] = new Inet4Address(null, addr);                } else {                    if (ifname != null) {                        ret[0] = new Inet6Address(null, addr, ifname);                    } else {                        ret[0] = new Inet6Address(null, addr, numericZone);                    }                }                return ret;            }        } else if (ipv6Expected) {            // We were expecting an IPv6 Litteral, but got something else            throw new UnknownHostException("["+host+"]");        }        return getAllByName0(host, reqAddr, true);    }    /**     * Returns the loopback address.     * <p>     * The InetAddress returned will represent the IPv4     * loopback address, 127.0.0.1, or the IPv6 loopback     * address, ::1. The IPv4 loopback address returned     * is only one of many in the form 127.*.*.*     *     * @return  the InetAddress loopback instance.     * @since 1.7     */    public static java.net.InetAddress getLoopbackAddress() {        return impl.loopbackAddress();    }    /**     * check if the literal address string has %nn appended     * returns -1 if not, or the numeric value otherwise.     *     * %nn may also be a string that represents the displayName of     * a currently available NetworkInterface.     */    private static int checkNumericZone (String s) throws UnknownHostException {        int percent = s.indexOf ('%');        int slen = s.length();        int digit, zone=0;        if (percent == -1) {            return -1;        }        for (int i=percent+1; i<slen; i++) {            char c = s.charAt(i);            if (c == ']') {                if (i == percent+1) {                    /* empty per-cent field */                    return -1;                }                break;            }            if ((digit = Character.digit (c, 10)) < 0) {                return -1;            }            zone = (zone * 10) + digit;        }        return zone;    }    private static java.net.InetAddress[] getAllByName0 (String host)            throws UnknownHostException    {        return getAllByName0(host, true);    }    /**     * package private so SocketPermission can call it     */    static java.net.InetAddress[] getAllByName0 (String host, boolean check)            throws UnknownHostException  {        return getAllByName0 (host, null, check);    }    private static java.net.InetAddress[] getAllByName0 (String host, java.net.InetAddress reqAddr, boolean check)            throws UnknownHostException  {        /*         * 检测该主机是否允许连接         */        if (check) {            SecurityManager security = System.getSecurityManager();            if (security != null) {                security.checkConnect(host, -1);            }        }        //获取缓存        java.net.InetAddress[] addresses = getCachedAddresses(host);        if (addresses == null) {            //查找            addresses = getAddressesFromNameService(host, reqAddr);        }        if (addresses == unknown_array)            throw new UnknownHostException(host);        return addresses.clone();    }    private static java.net.InetAddress[] getAddressesFromNameService(String host, java.net.InetAddress reqAddr)            throws UnknownHostException    {        java.net.InetAddress[] addresses = null;        boolean success = false;        UnknownHostException ex = null;        // Check whether the host is in the lookupTable.        // 1) If the host isn't in the lookupTable when        //    checkLookupTable() is called, checkLookupTable()        //    would add the host in the lookupTable and        //    return null. So we will do the lookup.        // 2) If the host is in the lookupTable when        //    checkLookupTable() is called, the current thread        //    would be blocked until the host is removed        //    from the lookupTable. Then this thread        //    should try to look up the addressCache.        //     i) if it found the addresses in the        //        addressCache, checkLookupTable()  would        //        return the addresses.        //     ii) if it didn't find the addresses in the        //         addressCache for any reason,        //         it should add the host in the        //         lookupTable and return null so the        //         following code would do  a lookup itself.        if ((addresses = checkLookupTable(host)) == null) {            try {                for (NameService nameService : nameServices) {                    try {                        addresses = nameService.lookupAllHostAddr(host);                        success = true;                        break;                    } catch (UnknownHostException uhe) {                        if (host.equalsIgnoreCase("localhost")) {                            java.net.InetAddress[] local = new java.net.InetAddress[] { impl.loopbackAddress() };                            addresses = local;                            success = true;                            break;                        }                        else {                            addresses = unknown_array;                            success = false;                            ex = uhe;                        }                    }                }                // More to do?                if (reqAddr != null && addresses.length > 1 && !addresses[0].equals(reqAddr)) {                    // Find it?                    int i = 1;                    for (; i < addresses.length; i++) {                        if (addresses[i].equals(reqAddr)) {                            break;                        }                    }                    // Rotate                    if (i < addresses.length) {                        java.net.InetAddress tmp, tmp2 = reqAddr;                        for (int j = 0; j < i; j++) {                            tmp = addresses[j];                            addresses[j] = tmp2;                            tmp2 = tmp;                        }                        addresses[i] = tmp2;                    }                }                // 加入缓存中                cacheAddresses(host, addresses, success);                if (!success && ex != null)                    throw ex;            } finally {                updateLookupTable(host);            }        }        return addresses;    }    private static java.net.InetAddress[] checkLookupTable(String host) {        synchronized (lookupTable) {            // If the host isn't in the lookupTable, add it in the            // lookuptable and return null. The caller should do            // the lookup.            if (lookupTable.containsKey(host) == false) {                lookupTable.put(host, null);                return null;            }            // If the host is in the lookupTable, it means that another            // thread is trying to look up the addresses of this host.            // This thread should wait.            while (lookupTable.containsKey(host)) {                try {                    lookupTable.wait();                } catch (InterruptedException e) {                }            }        }        // The other thread has finished looking up the addresses of        // the host. This thread should retry to get the addresses        // from the addressCache. If it doesn't get the addresses from        // the cache, it will try to look up the addresses itself.        java.net.InetAddress[] addresses = getCachedAddresses(host);        if (addresses == null) {            synchronized (lookupTable) {                lookupTable.put(host, null);                return null;            }        }        return addresses;    }    private static void updateLookupTable(String host) {        synchronized (lookupTable) {            lookupTable.remove(host);            lookupTable.notifyAll();        }    }    public static java.net.InetAddress getByAddress(byte[] addr)            throws UnknownHostException {        return getByAddress(null, addr);    }    private static java.net.InetAddress cachedLocalHost = null;    private static long cacheTime = 0;    private static final long maxCacheTime = 5000L;    private static final Object cacheLock = new Object();    public static java.net.InetAddress getLocalHost() throws UnknownHostException {        SecurityManager security = System.getSecurityManager();        try {            String local = impl.getLocalHostName();            if (security != null) {                security.checkConnect(local, -1);            }            if (local.equals("localhost")) {                return impl.loopbackAddress(); //返回  localhost/127.0.0.1            }            java.net.InetAddress ret = null;            synchronized (cacheLock) {                long now = System.currentTimeMillis();                if (cachedLocalHost != null) {                    if ((now - cacheTime) < maxCacheTime) // Less than 5s old?                        ret = cachedLocalHost;                    else                        cachedLocalHost = null;                }                if (ret == null) {                    java.net.InetAddress[] localAddrs;                    try {                        localAddrs =                                java.net.InetAddress.getAddressesFromNameService(local, null);                    } catch (UnknownHostException uhe) {                        // Rethrow with a more informative error message.                        UnknownHostException uhe2 =                                new UnknownHostException(local + ": " +                                        uhe.getMessage());                        uhe2.initCause(uhe);                        throw uhe2;                    }                    cachedLocalHost = localAddrs[0];                    cacheTime = now;                    ret = localAddrs[0];                }            }            return ret;        } catch (java.lang.SecurityException e) {            return impl.loopbackAddress();        }    }    /**     * Perform class load-time initializations.     */    private static native void init();    /*     * Returns the InetAddress representing anyLocalAddress     * (typically 0.0.0.0 or ::0)     */    static java.net.InetAddress anyLocalAddress() {        return impl.anyLocalAddress();    }    /*     * Load and instantiate an underlying impl class     */    static InetAddressImpl loadImpl(String implName) {        Object impl = null;        /*         * Property "impl.prefix" will be prepended to the classname         * of the implementation object we instantiate, to which we         * delegate the real work (like native methods).  This         * property can vary across implementations of the java.         * classes.  The default is an empty String "".         */        String prefix = AccessController.doPrivileged(                new GetPropertyAction("impl.prefix", ""));        try {            impl = Class.forName("java.net." + prefix + implName).newInstance();        } catch (ClassNotFoundException e) {            System.err.println("Class not found: java.net." + prefix +                    implName + ":\ncheck impl.prefix property " +                    "in your properties file.");        } catch (InstantiationException e) {            System.err.println("Could not instantiate: java.net." + prefix +                    implName + ":\ncheck impl.prefix property " +                    "in your properties file.");        } catch (IllegalAccessException e) {            System.err.println("Cannot access class: java.net." + prefix +                    implName + ":\ncheck impl.prefix property " +                    "in your properties file.");        }        if (impl == null) {            try {                impl = Class.forName(implName).newInstance();            } catch (Exception e) {                throw new Error("System property impl.prefix incorrect");            }        }        return (InetAddressImpl) impl;    }    private void readObjectNoData (ObjectInputStream s) throws            IOException, ClassNotFoundException {        if (getClass().getClassLoader() != null) {            throw new SecurityException ("invalid address type");        }    }    private static final long FIELDS_OFFSET;    private static final sun.misc.Unsafe UNSAFE;    static {        try {            sun.misc.Unsafe unsafe = sun.misc.Unsafe.getUnsafe();            FIELDS_OFFSET = unsafe.objectFieldOffset(                    java.net.InetAddress.class.getDeclaredField("holder")            );            UNSAFE = unsafe;        } catch (ReflectiveOperationException e) {            throw new Error(e);        }    }    private void readObject (ObjectInputStream s) throws            IOException, ClassNotFoundException {        if (getClass().getClassLoader() != null) {            throw new SecurityException ("invalid address type");        }        ObjectInputStream.GetField gf = s.readFields();        String host = (String)gf.get("hostName", null);        int address= gf.get("address", 0);        int family= gf.get("family", 0);        java.net.InetAddress.InetAddressHolder h = new java.net.InetAddress.InetAddressHolder(host, address, family);        UNSAFE.putObject(this, FIELDS_OFFSET, h);    }    /* needed because the serializable fields no longer exist */    /**     * @serialField hostName String     * @serialField address int     * @serialField family int     */    private static final ObjectStreamField[] serialPersistentFields = {            new ObjectStreamField("hostName", String.class),            new ObjectStreamField("address", int.class),            new ObjectStreamField("family", int.class),    };    private void writeObject (ObjectOutputStream s) throws            IOException {        if (getClass().getClassLoader() != null) {            throw new SecurityException ("invalid address type");        }        ObjectOutputStream.PutField pf = s.putFields();        pf.put("hostName", holder().getHostName());        pf.put("address", holder().getAddress());        pf.put("family", holder().getFamily());        s.writeFields();    }}/* * Simple factory to create the impl */class InetAddressImplFactory {    static InetAddressImpl create() {        return java.net.InetAddress.loadImpl(isIPv6Supported() ?                "Inet6AddressImpl" : "Inet4AddressImpl");    }    static native boolean isIPv6Supported();}