From ea2061b3337f865091e9c17a810ed115407e30ce Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=B0=8F=E5=BA=B7?= Date: Mon, 12 Jul 2021 09:29:50 +0800 Subject: [PATCH] =?UTF-8?q?=E5=A2=9E=E5=8A=A0NanoId=E7=AE=97=E6=B3=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- hutool-core/pom.xml | 4 +- .../main/java/cn/hutool/core/lang/NanoId.java | 104 +++++++++ .../main/java/cn/hutool/core/util/IdUtil.java | 30 ++- .../java/cn/hutool/core/lang/NanoIdTest.java | 201 ++++++++++++++++++ pom.xml | 6 + 5 files changed, 339 insertions(+), 6 deletions(-) create mode 100644 hutool-core/src/main/java/cn/hutool/core/lang/NanoId.java create mode 100644 hutool-core/src/test/java/cn/hutool/core/lang/NanoIdTest.java diff --git a/hutool-core/pom.xml b/hutool-core/pom.xml index 153941e05..d4df2fb11 100644 --- a/hutool-core/pom.xml +++ b/hutool-core/pom.xml @@ -1,7 +1,7 @@ + xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> 4.0.0 jar diff --git a/hutool-core/src/main/java/cn/hutool/core/lang/NanoId.java b/hutool-core/src/main/java/cn/hutool/core/lang/NanoId.java new file mode 100644 index 000000000..aa3f70d28 --- /dev/null +++ b/hutool-core/src/main/java/cn/hutool/core/lang/NanoId.java @@ -0,0 +1,104 @@ +package cn.hutool.core.lang; + +import java.security.SecureRandom; +import java.util.Random; + +/** + * A class for generating unique String IDs. + * + * The implementations of the core logic in this class are based on NanoId, a JavaScript + * library by Andrey Sitnik released under the MIT license. (https://github.com/ai/nanoid) + * + * @author David Klebanoff + */ +public final class NanoId { + + /** + * NanoIdUtils instances should NOT be constructed in standard programming. + * Instead, the class should be used as NanoIdUtils.randomNanoId();. + */ + private NanoId() { + //Do Nothing + } + + /** + * The default random number generator used by this class. + * Creates cryptographically strong NanoId Strings. + */ + public static final SecureRandom DEFAULT_NUMBER_GENERATOR = new SecureRandom(); + + /** + * The default alphabet used by this class. + * Creates url-friendly NanoId Strings using 64 unique symbols. + */ + public static final char[] DEFAULT_ALPHABET = + "_-0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray(); + + /** + * The default size used by this class. + * Creates NanoId Strings with slightly more unique values than UUID v4. + */ + public static final int DEFAULT_SIZE = 21; + + /** + * Static factory to retrieve a url-friendly, pseudo randomly generated, NanoId String. + * + * The generated NanoId String will have 21 symbols. + * + * The NanoId String is generated using a cryptographically strong pseudo random number + * generator. + * + * @return A randomly generated NanoId String. + */ + public static String randomNanoId() { + return randomNanoId(DEFAULT_NUMBER_GENERATOR, DEFAULT_ALPHABET, DEFAULT_SIZE); + } + + /** + * Static factory to retrieve a NanoId String. + * + * The string is generated using the given random number generator. + * + * @param random The random number generator. + * @param alphabet The symbols used in the NanoId String. + * @param size The number of symbols in the NanoId String. + * @return A randomly generated NanoId String. + */ + public static String randomNanoId(final Random random, final char[] alphabet, final int size) { + + if (random == null) { + throw new IllegalArgumentException("random cannot be null."); + } + + if (alphabet == null) { + throw new IllegalArgumentException("alphabet cannot be null."); + } + + if (alphabet.length == 0 || alphabet.length >= 256) { + throw new IllegalArgumentException("alphabet must contain between 1 and 255 symbols."); + } + + if (size <= 0) { + throw new IllegalArgumentException("size must be greater than zero."); + } + + final int mask = (2 << (int) Math.floor(Math.log(alphabet.length - 1) / Math.log(2))) - 1; + final int step = (int) Math.ceil(1.6 * mask * size / alphabet.length); + + final StringBuilder idBuilder = new StringBuilder(); + + while (true) { + final byte[] bytes = new byte[step]; + random.nextBytes(bytes); + for (int i = 0; i < step; i++) { + final int alphabetIndex = bytes[i] & mask; + if (alphabetIndex < alphabet.length) { + idBuilder.append(alphabet[alphabetIndex]); + if (idBuilder.length() == size) { + return idBuilder.toString(); + } + } + } + } + } +} diff --git a/hutool-core/src/main/java/cn/hutool/core/util/IdUtil.java b/hutool-core/src/main/java/cn/hutool/core/util/IdUtil.java index bee58320f..165b41217 100644 --- a/hutool-core/src/main/java/cn/hutool/core/util/IdUtil.java +++ b/hutool-core/src/main/java/cn/hutool/core/util/IdUtil.java @@ -1,12 +1,14 @@ package cn.hutool.core.util; import cn.hutool.core.exceptions.UtilException; -import cn.hutool.core.lang.ObjectId; -import cn.hutool.core.lang.Singleton; -import cn.hutool.core.lang.Snowflake; -import cn.hutool.core.lang.UUID; +import cn.hutool.core.lang.*; import cn.hutool.core.net.NetUtil; +import java.util.Random; + +import static cn.hutool.core.lang.NanoId.DEFAULT_ALPHABET; +import static cn.hutool.core.lang.NanoId.DEFAULT_NUMBER_GENERATOR; + /** * ID生成器工具类，此工具类中主要封装： * @@ -238,4 +240,24 @@ public class IdUtil { */ return (mpid.toString().hashCode() & 0xffff) % (maxWorkerId + 1); } + // ------------------------------------------------------------------- NanoId + /** + * 获取随机NanoId + * + * @return 随机NanoId + */ + public static String randomNanoId() { + return NanoId.randomNanoId(); + } + /** + * Static factory to retrieve a NanoId String. + * + * The string is generated using the given random number generator. + * + * @param size The number of symbols in the NanoId String. + * @return A randomly generated NanoId String. + */ + public static String randomNanoId(final int size){ + return NanoId.randomNanoId(DEFAULT_NUMBER_GENERATOR, DEFAULT_ALPHABET, size); + } } diff --git a/hutool-core/src/test/java/cn/hutool/core/lang/NanoIdTest.java b/hutool-core/src/test/java/cn/hutool/core/lang/NanoIdTest.java new file mode 100644 index 000000000..ab74b71a2 --- /dev/null +++ b/hutool-core/src/test/java/cn/hutool/core/lang/NanoIdTest.java @@ -0,0 +1,201 @@ +package cn.hutool.core.lang; + +import org.hamcrest.MatcherAssert; +import org.hamcrest.Matchers; +import org.junit.Test; +import org.junit.experimental.results.ResultMatchers; + +import java.lang.reflect.Constructor; +import java.lang.reflect.Modifier; +import java.security.SecureRandom; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.Random; +import java.util.Set; +import java.util.regex.Pattern; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +/** + * Tests for NanoIdUtils. + * + * @author David Klebanoff + * @see NanoId + */ +public class NanoIdTest { + + @Test + public void NanoId_VerifyClassIsFinal_Verified() { + if ((NanoId.class.getModifiers() & Modifier.FINAL) != Modifier.FINAL) { + fail("The class is not final"); + } + } + + @Test + public void NanoId_VerifyConstructorsArePrivate_Verified() { + for (final Constructor constructor : NanoId.class.getConstructors()) { + if ((constructor.getModifiers() & Modifier.PRIVATE) != Modifier.PRIVATE) { + fail("The class has a non-private constructor."); + } + } + } + + @Test + public void NanoId_Verify100KRandomNanoIdsAreUnique_Verified() { + + //It's not much, but it's a good sanity check I guess. + final int idCount = 100000; + final Set ids = new HashSet<>(idCount); + + for (int i = 0; i < idCount; i++) { + final String id = NanoId.randomNanoId(); + if (ids.contains(id) == false) { + ids.add(id); + } else { + fail("Non-unique ID generated: " + id); + } + } + + } + + @Test + public void NanoId_SeededRandom_Success() { + + //With a seed provided, we can know which IDs to expect, and subsequently verify that the + // provided random number generator is being used as expected. + final Random random = new Random(12345); + + final char[] alphabet = + ("_-0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ").toCharArray(); + + final int size = 21; + + final String[] expectedIds = new String[] {"kutqLNv1wDmIS56EcT3j7", "U497UttnWzKWWRPMHpLD7", + "7nj2dWW1gjKLtgfzeI8eC", "I6BXYvyjszq6xV7L9k2A9", "uIolcQEyyQIcn3iM6Odoa" }; + + for (final String expectedId : expectedIds) { + final String generatedId = NanoId.randomNanoId(random, alphabet, size); + assertEquals(expectedId, generatedId); + } + + } + + @Test + public void NanoId_VariousAlphabets_Success() { + + //Test ID generation with various alphabets consisting of 1 to 255 unique symbols. + for (int symbols = 1; symbols <= 255; symbols++) { + + final char[] alphabet = new char[symbols]; + for (int i = 0; i < symbols; i++) { + alphabet[i] = (char) i; + } + + final String id = NanoId + .randomNanoId(NanoId.DEFAULT_NUMBER_GENERATOR, alphabet, + NanoId.DEFAULT_SIZE); + + //Create a regex pattern that only matches to the characters in the alphabet + final StringBuilder patternBuilder = new StringBuilder(); + patternBuilder.append("^["); + for (final char character : alphabet) { + patternBuilder.append(Pattern.quote(String.valueOf(character))); + } + patternBuilder.append("]+$"); + + assertTrue(id.matches(patternBuilder.toString())); + } + + } + + @Test + public void NanoId_VariousSizes_Success() { + + //Test ID generation with all sizes between 1 and 1,000. + for (int size = 1; size <= 1000; size++) { + + final String id = NanoId.randomNanoId(NanoId.DEFAULT_NUMBER_GENERATOR, + NanoId.DEFAULT_ALPHABET, size); + + assertEquals(size, id.length()); + } + + } + + @Test + public void NanoId_WellDistributed_Success() { + + //Test if symbols in the generated IDs are well distributed. + + final int idCount = 100000; + final int idSize = 20; + final char[] alphabet = "abcdefghijklmnopqrstuvwxyz".toCharArray(); + + final Map charCounts = new HashMap<>(); + + for (int i = 0; i < idCount; i++) { + + final String id = NanoId + .randomNanoId(NanoId.DEFAULT_NUMBER_GENERATOR, alphabet, idSize); + + for (int j = 0; j < id.length(); j++) { + final String value = String.valueOf(id.charAt(j)); + + final Long charCount = charCounts.get(value); + if (charCount == null) { + charCounts.put(value, 1L); + } else { + charCounts.put(value, charCount + 1); + } + } + } + + //Verify the distribution of characters is pretty even + for (final Long charCount : charCounts.values()) { + final double distribution = (charCount * alphabet.length / (double) (idCount * idSize)); + MatcherAssert.assertThat(distribution, Matchers.closeTo(1.0, 0.05)); + } + + } + + @Test(expected = IllegalArgumentException.class) + public void randomNanoId_NullRandom_ExceptionThrown() { + NanoId.randomNanoId(null, new char[] {'a', 'b', 'c'}, 10); + } + + @Test(expected = IllegalArgumentException.class) + public void randomNanoId_NullAlphabet_ExceptionThrown() { + NanoId.randomNanoId(new SecureRandom(), null, 10); + } + + @Test(expected = IllegalArgumentException.class) + public void randomNanoId_EmptyAlphabet_ExceptionThrown() { + NanoId.randomNanoId(new SecureRandom(), new char[] {}, 10); + } + + @Test(expected = IllegalArgumentException.class) + public void randomNanoId_256Alphabet_ExceptionThrown() { + + //The alphabet is composed of 256 unique characters + final char[] largeAlphabet = new char[256]; + for (int i = 0; i < 256; i++) { + largeAlphabet[i] = (char) i; + } + + NanoId.randomNanoId(new SecureRandom(), largeAlphabet, 20); + + } + + @Test(expected = IllegalArgumentException.class) + public void randomNanoId_NegativeSize_ExceptionThrown() { + NanoId.randomNanoId(new SecureRandom(), new char[] {'a', 'b', 'c'}, -10); + } + + @Test(expected = IllegalArgumentException.class) + public void randomNanoId_ZeroSize_ExceptionThrown() { + NanoId.randomNanoId(new SecureRandom(), new char[] {'a', 'b', 'c'}, 0); + } +} diff --git a/pom.xml b/pom.xml index fb52bfe0e..8cadcf1d2 100644 --- a/pom.xml +++ b/pom.xml @@ -55,6 +55,12 @@ ${junit.version} test + + org.hamcrest + java-hamcrest + 2.0.0.0 + test + org.projectlombok lombok