增加NanoId算法

hutool-core/pom.xml

@@ -1,7 +1,7 @@
 <?xml version='1.0' encoding='utf-8'?>
 <project xmlns="http://maven.apache.org/POM/4.0.0"
-	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">
+		 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">
 	<modelVersion>4.0.0</modelVersion>
 
 	<packaging>jar</packaging>

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 {
+
+    /**
+     * <code>NanoIdUtils</code> instances should NOT be constructed in standard programming.
+     * Instead, the class should be used as <code>NanoIdUtils.randomNanoId();</code>.
+     */
+    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();
+                    }
+                }
+            }
+        }
+    }
+}

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

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<String> 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<String, Long> 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);
+    }
+}

pom.xml

@@ -55,6 +55,12 @@
 			<version>${junit.version}</version>
 			<scope>test</scope>
 		</dependency>
+		<dependency>
+			<groupId>org.hamcrest</groupId>
+			<artifactId>java-hamcrest</artifactId>
+			<version>2.0.0.0</version>
+			<scope>test</scope>
+		</dependency>
 		<dependency>
 			<groupId>org.projectlombok</groupId>
 			<artifactId>lombok</artifactId>