补充第11期作业：Long.fastUUID与UUID.toString之间的关系

一 UUID.toString方法与Long.fastUUID方法的关联

UUID类

public final class UUID implements java.io.Serializable, Comparable<UUID> {

	 public static UUID randomUUID() {

        SecureRandom ng = Holder.numberGenerator;

        byte[] randomBytes = new byte[16];

        ng.nextBytes(randomBytes); // 真正生成随机数的地方

        randomBytes[6]  &= 0x0f;  /* clear version        */

        randomBytes[6]  |= 0x40;  /* set to version 4     */

        randomBytes[8]  &= 0x3f;  /* clear variant        */

        randomBytes[8]  |= 0x80;  /* set to IETF variant  */

        return new UUID(randomBytes);

    }

    /*

     * The random number generator used by this class to create random

     * based UUIDs. In a holder class to defer initialization until needed.

     */

    private static class Holder {

        static final SecureRandom numberGenerator = new SecureRandom();

    }

    /*

     * The most significant 64 bits of this UUID.

     * @serial

     */

    private final long mostSigBits;

    /*

     * The least significant 64 bits of this UUID.

     * @serial

     */

    private final long leastSigBits;

    private UUID(byte[] data) {

        long msb = 0;

        long lsb = 0;

        assert data.length == 16 : "data must be 16 bytes in length";

        // long的64位：    8位    8位 8位 8位 8位 8位 8位 8位   8位

        // 简单说：msb = data[0]     ......      ......       data[7]

        for (int i=0; i<8; i++)

            msb = (msb << 8) | (data[i] & 0xff);

        // long的64位：    8位    8位 8位 8位 8位 8位 8位 8位   8位

        // 简单说：lsb = data[8]     ......      ......       data[15]

        for (int i=8; i<16; i++)

            lsb = (lsb << 8) | (data[i] & 0xff);

        this.mostSigBits = msb;

        this.leastSigBits = lsb;

    }

    // SharedSecrets javaLangAccess变量什么时候设置进去？

    // 答案是System

    private static final JavaLangAccess jla = SharedSecrets.getJavaLangAccess();

    public String toString() {

        return jla.fastUUID(leastSigBits, mostSigBits);// 实际调用了Long.fastUUID方法

    }

}

public final class System {

	/**

     * Initialize the system class.  Called after thread initialization.

     */

    private static void initPhase1() {

    	// ...

        setJavaLangAccess();

        // ...

    }

    private static void setJavaLangAccess() {

        // Allow privileged classes outside of java.lang

        // 匿名内部类注册

        SharedSecrets.setJavaLangAccess(new JavaLangAccess() {

		    // ......

            public String fastUUID(long lsb, long msb) {

                return Long.fastUUID(lsb, msb);

            }

        });

    }

}

public final class Long extends Number implements Comparable<Long> {

    // 其实就是提供UUID的toString方法.......

    static String fastUUID(long lsb, long msb) {

        if (COMPACT_STRINGS) {

            byte[] buf = new byte[36];

            formatUnsignedLong0(lsb,        4, buf, 24, 12);

            formatUnsignedLong0(lsb >>> 48, 4, buf, 19, 4);

            formatUnsignedLong0(msb,        4, buf, 14, 4);

            formatUnsignedLong0(msb >>> 16, 4, buf, 9,  4);

            formatUnsignedLong0(msb >>> 32, 4, buf, 0,  8);

            buf[23] = '-';

            buf[18] = '-';

            buf[13] = '-';

            buf[8]  = '-';

            return new String(buf, LATIN1);

        } else {

            byte[] buf = new byte[72];

            formatUnsignedLong0UTF16(lsb,        4, buf, 24, 12);

            formatUnsignedLong0UTF16(lsb >>> 48, 4, buf, 19, 4);

            formatUnsignedLong0UTF16(msb,        4, buf, 14, 4);

            formatUnsignedLong0UTF16(msb >>> 16, 4, buf, 9,  4);

            formatUnsignedLong0UTF16(msb >>> 32, 4, buf, 0,  8);

            StringUTF16.putChar(buf, 23, '-');

            StringUTF16.putChar(buf, 18, '-');

            StringUTF16.putChar(buf, 13, '-');

            StringUTF16.putChar(buf,  8, '-');

            return new String(buf, UTF16);

        }

    }

}

UUID的组成部分

参考：http://www.ietf.org/rfc/rfc4122.txt

UUID  = time-low "-" time-mid "-" time-high-and-version "-" clock-seq-and-reserved clock-seq-low "-" node

time-low               = 4hexOctet

time-mid               = 2hexOctet

time-high-and-version  = 2hexOctet

clock-seq-and-reserved = hexOctet

clock-seq-low          = hexOctet

node                   = 6hexOctet

hexOctet               = hexDigit hexDigit

hexDigit =

"0" / "1" / "2" / "3" / "4" / "5" / "6" / "7" / "8" / "9" /

"a" / "b" / "c" / "d" / "e" / "f" /

"A" / "B" / "C" / "D" / "E" / "F"

二 Java加密体系结构（JCA）

参考：https://blog.csdn.net/u012741741/article/details/79209984

这篇译文很好，不过本文不是为了讲解加密体系，所以尽量只获取最少的额外知识点来完成UUID.randomUUID的剖析

1 介绍

JAVA平台强调安全性，包含内容很多如：语言安全，密码学，公钥基础设施，认证，安全通信和访问控制。
JCA是JAVA平台的一部分，提供一个“Provider”体系结构和一组用于数字签名，消息摘要（哈希），证书和证书验证，加密（对称/非对称块/流密码），密钥生成管理和安全随机数生成等等。有了这些API，开发人员可以轻松将安全性集成到自己的应用中。
JCA设计原则：
- 实现独立性：应用程序不需要自己实现安全性，它们可以从Java平台请求安全服务。
- 实现互操作性：Provider不需要绑定到固定的应用中，应用也不需要绑定特定的Provider。
- 算法可拓展性： Java平台包含许多内置的Provider，这些Provider实现了当今广泛使用的一组基本的安全服务。但也许有些应用希望集成新兴的算法。

2 UUID中涉及JCA的类

SecureRandom：它是一个随机数生成器（RNG），同时是JCA中的其中一个引擎类。引擎类为特定类型的密码服务提供接口，而不依赖于特定的密码算法或提供者。
SecureRandomSpi：该类定义了SecureRandom的服务提供者接口（SPI），意味着为SecureRandom提供具体实现的生成器需要实现该类的所有方法。
DRBG：它实现了"SecureRandom.DRBG"算法，是SecureRandom的其中一个随机数生成器实现。
Provider：该类表示Java安全API的“提供者”，其中某个具体提供者需要实现Java安全的部分或全部部分。
Sun：Sun的安全提供者，Provider的子类。
Provider.Service：Provider的内部类，封装SPI的具体实现类，通过Service能够找到具体的实现类

3 SecureRandom的具体实现类追寻

（1）找出Jdk中有许多Providers，许多官方的，或者第三方添加。如：Sun、SunJCE、JdkLDAP、XMLLDSig等

（2）顺序遍历Providers并解析Providers中提供的算法为Services，如：

SecureRandom.DRBG -> sun.security.provider.DRBG
MessageDigest.SHA -> sun.security.provider.SHA
Alg.Alias.KeyPairGenerator.1.2.8400.10040.4.1 -> DSA
Alg.Alias.CertificateFactory.X509 -> X.509
Provider.id info -> SUN(DSA key/parameter generation; DSA signing; SHA-1 , MD5...)
.....

（3）发现DRBG是SecureRandom的具体提供者

（4）根据DRBG的全类名创建对象并返回使用

4 通过代码跟踪看看

public class SecureRandom extends java.util.Random {

    public SecureRandom() {

        super(0);

        getDefaultPRNG(false, null);

        this.threadSafe = getThreadSafe();

   }

   private void getDefaultPRNG(boolean setSeed, byte[] seed) {

        String prng = getPrngAlgorithm(); // 返回"DRBG"

        if (prng == null) {

            prng = "SHA1PRNG";

            this.secureRandomSpi = new sun.security.provider.SecureRandom();

            this.provider = Providers.getSunProvider();

            if (setSeed) this.secureRandomSpi.engineSetSeed(seed);

        } else {

            try {

                SecureRandom random = SecureRandom.getInstance(prng);

                this.secureRandomSpi = random.getSecureRandomSpi();

                this.provider = random.getProvider();

                if (setSeed) {

                    this.secureRandomSpi.engineSetSeed(seed);

                }

            } catch (NoSuchAlgorithmException nsae) {

                throw new RuntimeException(nsae);

            }

        }

        if (getClass() == SecureRandom.class) {

            this.algorithm = prng;

        }

    }

    private static String getPrngAlgorithm() {

        for (Provider p : Providers.getProviderList().providers()) {

            for (Service s : p.getServices()) {

                if (s.getType().equals("SecureRandom"))  return s.getAlgorithm();

            }

        }

        return null;

    }

   public static SecureRandom getInstance(String algorithm) throws NoSuchAlgorithmException {

        Instance instance = GetInstance.getInstance("SecureRandom",

                                                    SecureRandomSpi.class,

                                                    algorithm);

        return new SecureRandom((SecureRandomSpi)instance.impl,

                                instance.provider, algorithm);

    }

}

public class GetInstance {

	public static Instance getInstance(String type, Class<?> clazz,

            String algorithm) throws NoSuchAlgorithmException {

        ProviderList list = Providers.getProviderList();

        Service firstService = list.getService(type, algorithm);

        return getInstance(firstService, clazz);

    }

     public static Instance getInstance(Service s, Class<?> clazz)

            throws NoSuchAlgorithmException {

        Object instance = s.newInstance(null);

        return new Instance(s.getProvider(), instance);

    }

}

public class Provider{

    public class Service{

        public Object newInstance(Object constructorParameter)

                throws NoSuchAlgorithmException {

            Class<?> ctrParamClz;

            EngineDescription cap = knownEngines.get(type);

            if (cap == null) {

                ctrParamClz = constructorParameter == null?

                    null : constructorParameter.getClass();

            } else {

                ctrParamClz = cap.constructorParameterClassName == null?

                    null : Class.forName(cap.constructorParameterClassName);

            }

            return newInstanceUtil(getImplClass(), ctrParamClz, constructorParameter);

        }

        // 返回class sun.security.provider.DRBG

        // return the implementation Class object for this service

        private Class<?> getImplClass() throws NoSuchAlgorithmException {

            Reference<Class<?>> ref = classRef;

            Class<?> clazz = (ref == null) ? null : ref.get();

            ClassLoader cl = provider.getClass().getClassLoader();

            if (cl == null) {

                clazz = Class.forName(className);//className为sun.security.provider.DRBG

            } else {

                clazz = cl.loadClass(className);

            }

            classRef = new WeakReference<>(clazz);

            return clazz;

        }

    }

     private static Object newInstanceUtil(final Class<?> clazz,

        final Class<?> ctrParamClz, final Object ctorParamObj)

        throws Exception {

        if (ctrParamClz == null) {

            Constructor<?> con = clazz.getConstructor();

            // 最后就是构造器的newInstance

            return con.newInstance();

        } else {

            Constructor<?> con = clazz.getConstructor(ctrParamClz);

            return con.newInstance(ctorParamObj);

        }

    }

}

巴特西

补充第11期作业：Long.fastUUID与UUID.toString之间的关系

一 UUID.toString方法与Long.fastUUID方法的关联

二 Java加密体系结构（JCA）

1 介绍

2 UUID中涉及JCA的类

3 SecureRandom的具体实现类追寻

4 通过代码跟踪看看

最新文章

热门文章