From f80c47e8adb9c7810de4ad68890a00593a346ce6 Mon Sep 17 00:00:00 2001
From: Zihlu Wang <really@zihlu.wang>
Date: Mon, 18 Sep 2023 15:04:10 +0800
Subject: [PATCH] docs(global): Optimised javadoc, changed the spelling to
 British English.

---
 .../devkit/core/exceptions/package-info.java  |  2 +-
 .../devkit/core/package-info.java             | 11 +--
 .../org/codecrafters/devkit/package-info.java |  4 +-
 .../codecrafters/devkit/utils/AesUtil.java    | 48 +++++-----
 .../codecrafters/devkit/utils/Base64Util.java | 39 ++++++--
 .../codecrafters/devkit/utils/BranchUtil.java | 18 ++--
 .../devkit/utils/ChainedCalcUtil.java         | 71 +++++++--------
 .../codecrafters/devkit/utils/HashUtil.java   | 14 ++-
 .../codecrafters/devkit/utils/MapUtil.java    | 12 +--
 .../guid/SnowflakeGuidCreator.java            | 18 ++--
 .../guid/exceptions/TimingException.java      | 14 +--
 property-guard-spring-boot-starter/README.md  |  2 +-
 .../autoconfiguration/PropertyGuard.java      | 29 ++++--
 .../authzero/AuthzeroTokenResolver.java       | 51 +++++------
 .../config/AuthzeroTokenResolverConfig.java   | 91 +++++++++----------
 .../simplejwt/authzero/package-info.java      | 25 ++---
 .../codecrafters/simplejwt/SecretCreator.java | 20 ++--
 .../codecrafters/simplejwt/TokenPayload.java  |  8 +-
 .../codecrafters/simplejwt/TokenResolver.java |  8 +-
 .../annotations/ExcludeFromPayload.java       | 15 ++-
 .../simplejwt/config/TokenResolverConfig.java | 34 ++++---
 .../simplejwt/config/package-info.java        | 13 +--
 .../simplejwt/constants/PredefinedKeys.java   |  8 +-
 .../simplejwt/constants/TokenAlgorithm.java   |  4 +-
 .../UnsupportedAlgorithmException.java        | 48 +++++-----
 .../exceptions/WeakSecretException.java       | 54 ++++++-----
 .../simplejwt/exceptions/package-info.java    | 18 ++--
 .../codecrafters/simplejwt/package-info.java  | 22 ++---
 .../simplejwt/jjwt/JjwtTokenResolver.java     |  8 +-
 .../jjwt/config/JjwtTokenResolverConfig.java  | 46 +++++-----
 .../simplejwt/jjwt/package-info.java          | 20 ++--
 ...uthzeroTokenResolverAutoConfiguration.java | 15 +--
 .../GuidAutoConfiguration.java                |  2 +-
 .../JjwtTokenResolverAutoConfiguration.java   |  6 +-
 .../conditions/GuidCreatorCondition.java      |  2 +-
 .../properties/SimpleJwtProperties.java       | 12 +--
 .../org/codecrafters/webcal/WebCalendar.java  | 19 ++--
 .../codecrafters/webcal/WebCalendarEvent.java | 19 ++--
 .../codecrafters/webcal/WebCalendarNode.java  | 13 ++-
 .../webcal/config/Classification.java         | 26 +-----
 .../webcal/config/package-info.java           |  8 +-
 41 files changed, 459 insertions(+), 438 deletions(-)

diff --git a/devkit-core/src/main/java/cn/org/codecrafters/devkit/core/exceptions/package-info.java b/devkit-core/src/main/java/cn/org/codecrafters/devkit/core/exceptions/package-info.java
index 826c497..dfac4fe 100644
--- a/devkit-core/src/main/java/cn/org/codecrafters/devkit/core/exceptions/package-info.java
+++ b/devkit-core/src/main/java/cn/org/codecrafters/devkit/core/exceptions/package-info.java
@@ -16,7 +16,7 @@
  */
 
 /**
- * Commonly used exceptions will be used in JDevKit.
+ * This package contains commonly used exceptions will be used in JDevKit.
  *
  * @author Zihlu Wang
  * @since 1.0.0
diff --git a/devkit-core/src/main/java/cn/org/codecrafters/devkit/core/package-info.java b/devkit-core/src/main/java/cn/org/codecrafters/devkit/core/package-info.java
index 3dda72c..a7e930f 100644
--- a/devkit-core/src/main/java/cn/org/codecrafters/devkit/core/package-info.java
+++ b/devkit-core/src/main/java/cn/org/codecrafters/devkit/core/package-info.java
@@ -16,19 +16,16 @@
  */
 
 /**
- * This package is a part of JDevKit, an open-source Java Development Kit that
- * provides a set of convenient tools to streamline code development and
- * enhance productivity. This package serves as the core package containing
- * common exceptions that are used throughout the entireJDevKit project.
- *
+ * This package is the core part of JDevKit, an open-source Java Development
+ * Kit that provides a set of convenient tools to streamline code development
+ * and enhance productivity. This package serves as the core package containing
+ * common exceptions that are used throughout the entire JDevKit project.
  * <p>
  * JDevKit is designed to be modular, and other specific feature modules within
  * the library may rely on these exceptions from the core package.
- *
  * <p>
  * For more information and the latest version of JDevKit, please visit our
  * website <a href="https://codecrafters.org.cn">codecrafters.org.cn</a>.
- *
  * <p>
  * <b>Contact</b>
  * <ul>
diff --git a/devkit-core/src/main/java/cn/org/codecrafters/devkit/package-info.java b/devkit-core/src/main/java/cn/org/codecrafters/devkit/package-info.java
index 0bfad9b..90647f4 100644
--- a/devkit-core/src/main/java/cn/org/codecrafters/devkit/package-info.java
+++ b/devkit-core/src/main/java/cn/org/codecrafters/devkit/package-info.java
@@ -19,8 +19,8 @@
  * This package is the main part of JDevKit, an open-source Java class library
  * that provides a set of convenient tools to streamline code development and
  * enhance productivity. This package serves as the root package for several
- * modules, containing devkit-core, guid and dev-utils module.
- *
+ * modules, containing {@code devkit-core}, {@code guid} and {@code dev-utils}
+ * module.
  * <p>
  * For more information and the latest version of JDevKit, please visit our
  * website <a href="https://codecrafters.org.cn">codecrafters.org.cn</a>.
diff --git a/devkit-utils/src/main/java/cn/org/codecrafters/devkit/utils/AesUtil.java b/devkit-utils/src/main/java/cn/org/codecrafters/devkit/utils/AesUtil.java
index 54a734c..6ccc4ce 100644
--- a/devkit-utils/src/main/java/cn/org/codecrafters/devkit/utils/AesUtil.java
+++ b/devkit-utils/src/main/java/cn/org/codecrafters/devkit/utils/AesUtil.java
@@ -34,12 +34,12 @@ import java.util.Objects;
 import java.util.UUID;
 
 /**
- * AES Util helps you encrypt and decrypt data with specified key and AES
- * algorithm.
+ * {@link AesUtil} can help you encrypt and decrypt data with specified secret
+ * by AES algorithm.
  *
  * @author hubin@baomidou
- * @since 1.1.0
  * @version 1.1.0
+ * @since 1.1.0
  */
 @Slf4j
 public final class AesUtil {
@@ -52,17 +52,17 @@ public final class AesUtil {
     private static final String AES_CBC_CIPHER = "AES/CBC/PKCS5Padding";
 
     /**
-     * Encrypt the given data with given key with AES algorithm.
+     * Encrypts the data using the AES algorithm with the given secret.
      *
-     * @param data the data to be encrypted
-     * @param key  the key to encrypt the data
+     * @param data   the data to be encrypted
+     * @param secret the secret to encrypt the data
      * @return the encryption result or {@code null} if encryption failed
      */
-    public static byte[] encrypt(byte[] data, byte[] key) {
+    public static byte[] encrypt(byte[] data, byte[] secret) {
         try {
-            var secretKeySpec = new SecretKeySpec(new SecretKeySpec(key, AES).getEncoded(), AES);
+            var secretKeySpec = new SecretKeySpec(new SecretKeySpec(secret, AES).getEncoded(), AES);
             var cipher = Cipher.getInstance(AES_CBC_CIPHER);
-            cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, new IvParameterSpec(key));
+            cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, new IvParameterSpec(secret));
             return cipher.doFinal(data);
         } catch (NoSuchAlgorithmException | NoSuchPaddingException | UnsupportedOperationException |
                  InvalidKeyException | InvalidAlgorithmParameterException | IllegalBlockSizeException |
@@ -76,17 +76,17 @@ public final class AesUtil {
     }
 
     /**
-     * Decrypt the given data with given key with AES algorithm.
+     * Decrypts the data using the AES algorithm with the given secret.
      *
      * @param data the data to be decrypted
-     * @param key  the key to encrypt the data
+     * @param secret  the secret to encrypt the data
      * @return the decryption result or {@code null} if decryption failed
      */
-    public static byte[] decrypt(byte[] data, byte[] key) {
+    public static byte[] decrypt(byte[] data, byte[] secret) {
         try {
-            var secretKeySpec = new SecretKeySpec(new SecretKeySpec(key, AES).getEncoded(), AES);
+            var secretKeySpec = new SecretKeySpec(new SecretKeySpec(secret, AES).getEncoded(), AES);
             var cipher = Cipher.getInstance(AES_CBC_CIPHER);
-            cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, new IvParameterSpec(key));
+            cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, new IvParameterSpec(secret));
             return cipher.doFinal(data);
         } catch (NoSuchAlgorithmException | NoSuchPaddingException | UnsupportedOperationException |
                  InvalidKeyException | InvalidAlgorithmParameterException | IllegalBlockSizeException |
@@ -100,36 +100,36 @@ public final class AesUtil {
     }
 
     /**
-     * Encrypt the given data with given key with AES algorithm.
+     * Encrypts the data using the AES algorithm with the given secret.
      *
      * @param data the data to be encrypted
-     * @param key  the key to encrypt the data
+     * @param secret  the secret to encrypt the data
      * @return the encryption result or {@code null} if encryption failed
      */
-    public static String encrypt(String data, String key) {
-        return Base64.getEncoder().encodeToString(encrypt(data.getBytes(StandardCharsets.UTF_8), key.getBytes(StandardCharsets.UTF_8)));
+    public static String encrypt(String data, String secret) {
+        return Base64.getEncoder().encodeToString(encrypt(data.getBytes(StandardCharsets.UTF_8), secret.getBytes(StandardCharsets.UTF_8)));
     }
 
     /**
-     * Decrypt the given data with given key with AES algorithm.
+     * Decrypts the data using the AES algorithm with the given secret.
      *
      * @param data the data to be decrypted
-     * @param key  the key to encrypt the data
+     * @param secret  the secret to encrypt the data
      * @return the decryption result or {@code null} if decryption failed
      */
-    public static String decrypt(String data, String key) {
+    public static String decrypt(String data, String secret) {
         return new String(Objects.requireNonNull(
                 decrypt(Base64.getDecoder().decode(data.getBytes()),
-                        key.getBytes(StandardCharsets.UTF_8)))
+                        secret.getBytes(StandardCharsets.UTF_8)))
         );
     }
 
     /**
-     * Generates 16 characters-long random key.
+     * Generates 16 characters-long random secret.
      *
      * @return the generated secure secret
      */
-    public static String generateRandomKey() {
+    public static String generateRandomSecret() {
         return UUID.randomUUID().toString().replaceAll("-", "").substring(0, 16);
     }
 
diff --git a/devkit-utils/src/main/java/cn/org/codecrafters/devkit/utils/Base64Util.java b/devkit-utils/src/main/java/cn/org/codecrafters/devkit/utils/Base64Util.java
index 96377d4..309b83c 100644
--- a/devkit-utils/src/main/java/cn/org/codecrafters/devkit/utils/Base64Util.java
+++ b/devkit-utils/src/main/java/cn/org/codecrafters/devkit/utils/Base64Util.java
@@ -20,10 +20,11 @@ package cn.org.codecrafters.devkit.utils;
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
 import java.util.Base64;
+import java.util.Objects;
 
 /**
- * The {@code Base64Util} class provides static methods to encode and decode
- * strings using Base64 encoding. It utilizes the {@link Base64} class from the
+ * The {@link Base64Util} class provides static methods to encode and decode
+ * strings with Base64 encoding. It utilizes the {@link Base64} class from the
  * Java standard library for performing the encoding and decoding operations.
  * This utility class offers convenient methods to encode and decode strings
  * with different character sets.
@@ -55,6 +56,34 @@ import java.util.Base64;
  */
 public final class Base64Util {
 
+    private static Base64.Encoder encoder;
+
+    private static Base64.Decoder decoder;
+
+    /**
+     * Ensure that there is only one Base64 Encoder.
+     *
+     * @return the {@link Base64.Encoder} instance
+     */
+    private static Base64.Encoder getEncoder() {
+        if (Objects.isNull(encoder)) {
+            encoder = Base64.getEncoder();
+        }
+        return encoder;
+    }
+
+    /**
+     * Ensure that there is only one Base64 Encoder.
+     *
+     * @return the {@link Base64.Encoder} instance
+     */
+    private static Base64.Decoder getDecoder() {
+        if (Objects.isNull(decoder)) {
+            decoder = Base64.getDecoder();
+        }
+        return decoder;
+    }
+
     /**
      * Private constructor to prevent instantiation of the class.
      */
@@ -69,8 +98,7 @@ public final class Base64Util {
      * @return the Base64 encoded string
      */
     public static String encode(String value, Charset charset) {
-        var encoder = Base64.getEncoder();
-        var encoded = encoder.encode(value.getBytes(charset));
+        var encoded = getEncoder().encode(value.getBytes(charset));
 
         return new String(encoded);
     }
@@ -93,8 +121,7 @@ public final class Base64Util {
      * @return the decoded string
      */
     public static String decode(String value, Charset charset) {
-        var decoder = Base64.getDecoder();
-        var decoded = decoder.decode(value.getBytes(charset));
+        var decoded = getDecoder().decode(value.getBytes(charset));
 
         return new String(decoded);
     }
diff --git a/devkit-utils/src/main/java/cn/org/codecrafters/devkit/utils/BranchUtil.java b/devkit-utils/src/main/java/cn/org/codecrafters/devkit/utils/BranchUtil.java
index 288f2f4..6b9b760 100644
--- a/devkit-utils/src/main/java/cn/org/codecrafters/devkit/utils/BranchUtil.java
+++ b/devkit-utils/src/main/java/cn/org/codecrafters/devkit/utils/BranchUtil.java
@@ -23,24 +23,24 @@ import java.util.function.BooleanSupplier;
 import java.util.function.Supplier;
 
 /**
- * The BranchUtil class provides static methods to simplify conditional logic
- * in Java development by leveraging lambda expressions. It offers convenient
- * methods to replace verbose if...else statements with more concise and
- * expressive functional constructs.
+ * The {@link BranchUtil} class provides static methods to simplify conditional
+ * logic in Java development by leveraging lambda expressions. It offers
+ * convenient methods to replace verbose {@code if...else} statements with more
+ * concise and expressive functional constructs.
  * <p>
- * Developers can use the methods in this utility class to streamline their
- * code, enhance readability, and promote a more functional style of
- * programming when dealing with branching logic and conditional statements.
+ * Developers can use methods in this utility class to streamline their code,
+ * enhance readability, and promote a more functional style of programming when
+ * dealing with branching logic and conditional statements.
  * <p>
  * <b>Example:</b>
  * <pre>
  * // If you want to simplify an if (exp1 || exp2), you can use the
  * // following code:
- * var r1 = BranchUtil.or(1 == 1, 2 == 1)
+ * String r1 = BranchUtil.or(1 == 1, 2 == 1)
  *     .handle(() -> "1 is equal to 1 or 2 is equal to 1.");
  *
  * // If you have an else branch, you can use the following code:
- * var r2 = BranchUtil.or(1 == 1, 2 == 1)
+ * String r2 = BranchUtil.or(1 == 1, 2 == 1)
  *     .handle(() -> "1 is equal to 1 or 2 is equal to 1.",
  *             () -> "1 is not equal to 1 and 2 is not equal to 1.");
  *
diff --git a/devkit-utils/src/main/java/cn/org/codecrafters/devkit/utils/ChainedCalcUtil.java b/devkit-utils/src/main/java/cn/org/codecrafters/devkit/utils/ChainedCalcUtil.java
index 21a9273..fc2358c 100644
--- a/devkit-utils/src/main/java/cn/org/codecrafters/devkit/utils/ChainedCalcUtil.java
+++ b/devkit-utils/src/main/java/cn/org/codecrafters/devkit/utils/ChainedCalcUtil.java
@@ -26,14 +26,12 @@ import java.util.function.BiFunction;
 import java.util.function.Function;
 
 /**
- * Utility class for chained high-precision calculations using BigDecimal.
- * <p>
- * The ChainedCalcUtil class provides a convenient way to perform chained
- * high-precision calculations using BigDecimal. It allows users to perform
- * mathematical operations such as addition, subtraction, multiplication,
- * and division with customisable precision and scale. By using this utility
- * class, developers can achieve accurate results and avoid precision loss
- * in their calculations.
+ * The {@code ChainedCalcUtil} class provides a convenient way to perform
+ * chained high-precision calculations using {@link BigDecimal}. It allows
+ * users to perform mathematical operations such as addition, subtraction,
+ * multiplication, and division with customisable precision and scale. By using
+ * this utility class, developers can achieve accurate results and avoid
+ * precision loss in their calculations.
  * <p>
  * <b>Usage:</b>
  * <pre>
@@ -81,13 +79,13 @@ import java.util.function.Function;
  *                                      .getValue(2);
  *  </pre>
  * The above expressions perform various mathematical calculations using the
- * ChainedCalcUtil class.
+ * {@code ChainedCalcUtil} class.
  * <p>
  * <b>Note:</b>
- * The ChainedCalcUtil class internally uses BigDecimal to handle
- * high-precision calculations. It is important to note that BigDecimal
- * operations can be memory-intensive and may have performance implications
- * for extremely large numbers or complex calculations.
+ * The {@code ChainedCalcUtil} class internally uses {@link BigDecimal} to
+ * handle high-precision calculations. It is important to note that {@link
+ * BigDecimal} operations can be memory-intensive and may have performance
+ * implications for extremely large numbers or complex calculations.
  *
  * @author sunzsh
  * @version 1.1.0
@@ -104,7 +102,8 @@ public final class ChainedCalcUtil {
     private BigDecimal value;
 
     /**
-     * Creates a ChainedCalcUtil instance with the specified initial value.
+     * Creates a {@code ChainedCalcUtil} instance with the specified initial
+     * value.
      *
      * @param value the initial value for the calculation
      */
@@ -116,7 +115,7 @@ public final class ChainedCalcUtil {
      * Starts a chained calculation with the specified initial value.
      *
      * @param value the initial value for the calculation
-     * @return a ChainedCalcUtil instance for performing chained calculations
+     * @return a {@code ChainedCalcUtil} instance for performing chained calculations
      */
     public static ChainedCalcUtil startWith(Number value) {
         return new ChainedCalcUtil(value);
@@ -126,7 +125,7 @@ public final class ChainedCalcUtil {
      * Adds the specified value to the current value.
      *
      * @param other the value to be added
-     * @return a ChainedCalcUtil instance with the updated value
+     * @return a {@code ChainedCalcUtil} instance with the updated value
      */
     public ChainedCalcUtil add(Number other) {
         return operator(BigDecimal::add, other);
@@ -138,7 +137,7 @@ public final class ChainedCalcUtil {
      *
      * @param other              the value to be added
      * @param beforeOperateScale the scale to be applied before the operation
-     * @return a ChainedCalcUtil instance with the updated value
+     * @return a {@code ChainedCalcUtil} instance with the updated value
      */
     public ChainedCalcUtil add(Number other, Integer beforeOperateScale) {
         return operator(BigDecimal::add, other, beforeOperateScale);
@@ -148,7 +147,7 @@ public final class ChainedCalcUtil {
      * Subtracts the specified value from the current value.
      *
      * @param other the value to be subtracted
-     * @return a ChainedCalcUtil instance with the updated value
+     * @return a {@code ChainedCalcUtil} instance with the updated value
      */
     public ChainedCalcUtil subtract(Number other) {
         return operator(BigDecimal::subtract, other);
@@ -160,7 +159,7 @@ public final class ChainedCalcUtil {
      *
      * @param other              the value to be subtracted
      * @param beforeOperateScale the scale to be applied before the operation
-     * @return a ChainedCalcUtil instance with the updated value
+     * @return a {@code ChainedCalcUtil} instance with the updated value
      */
     public ChainedCalcUtil subtract(Number other, Integer beforeOperateScale) {
         return operator(BigDecimal::subtract, other, beforeOperateScale);
@@ -170,7 +169,7 @@ public final class ChainedCalcUtil {
      * Multiplies the current value by the specified value.
      *
      * @param other the value to be multiplied by
-     * @return a ChainedCalcUtil instance with the updated value
+     * @return a {@code ChainedCalcUtil} instance with the updated value
      */
     public ChainedCalcUtil multiply(Number other) {
         return operator(BigDecimal::multiply, other);
@@ -182,7 +181,7 @@ public final class ChainedCalcUtil {
      *
      * @param other              the value to be multiplied by
      * @param beforeOperateScale the scale to be applied before the operation
-     * @return a ChainedCalcUtil instance with the updated value
+     * @return a {@code ChainedCalcUtil} instance with the updated value
      */
     public ChainedCalcUtil multiply(Number other, Integer beforeOperateScale) {
         return operator(BigDecimal::multiply, other, beforeOperateScale);
@@ -192,7 +191,7 @@ public final class ChainedCalcUtil {
      * Divides the current value by the specified value.
      *
      * @param other the value to divide by
-     * @return a ChainedCalcUtil instance with the updated value
+     * @return a {@code ChainedCalcUtil} instance with the updated value
      */
     public ChainedCalcUtil divide(Number other) {
         return operator(BigDecimal::divide, other);
@@ -204,7 +203,7 @@ public final class ChainedCalcUtil {
      *
      * @param other              the value to divide by
      * @param beforeOperateScale the scale to be applied before the operation
-     * @return a ChainedCalcUtil instance with the updated value
+     * @return a {@code ChainedCalcUtil} instance with the updated value
      */
     public ChainedCalcUtil divide(Number other, Integer beforeOperateScale) {
         return operator(BigDecimal::divide, other, beforeOperateScale);
@@ -215,7 +214,7 @@ public final class ChainedCalcUtil {
      *
      * @param other the value to divide by
      * @param scale the scale for the result
-     * @return a ChainedCalcUtil instance with the updated value
+     * @return a {@code ChainedCalcUtil} instance with the updated value
      */
     public ChainedCalcUtil divideWithScale(Number other, Integer scale) {
         return baseOperator(otherValue ->
@@ -229,54 +228,54 @@ public final class ChainedCalcUtil {
      * @param other              the value to divide by
      * @param scale              the scale for the result
      * @param beforeOperateScale the scale to be applied before the operation
-     * @return a ChainedCalcUtil instance with the updated value
+     * @return a {@code ChainedCalcUtil} instance with the updated value
      */
     public ChainedCalcUtil divideWithScale(Number other, Integer scale, Integer beforeOperateScale) {
         return baseOperator(otherValue -> this.value.divide(otherValue, scale, RoundingMode.HALF_UP), other, beforeOperateScale);
     }
 
     /**
-     * Returns the current value as a BigDecimal with the specified scale.
+     * Returns the current value as a {@link BigDecimal} with the specified scale.
      *
      * @param scale the scale for the result
-     * @return the current value as a BigDecimal with the specified scale
+     * @return the current value as a {@link BigDecimal} with the specified scale
      */
     public BigDecimal getValue(int scale) {
         return value.setScale(scale, RoundingMode.HALF_UP);
     }
 
     /**
-     * Returns the current value as a Double.
+     * Returns the current value as a {@link Double}.
      *
-     * @return the current value as a Double
+     * @return the current value as a {@link Double}
      */
     public Double getDouble() {
         return getValue().doubleValue();
     }
 
     /**
-     * Returns the current value as a Double with the specified scale.
+     * Returns the current value as a {@link Double} with the specified scale.
      *
      * @param scale the scale for the result
-     * @return the current value as a Double with the specified scale
+     * @return the current value as a {@link Double} with the specified scale
      */
     public Double getDouble(int scale) {
         return getValue(scale).doubleValue();
     }
 
     /**
-     * Returns the current value as a Long.
+     * Returns the current value as a {@link Long}.
      *
-     * @return the current value as a Long
+     * @return the current value as a {@link Long}
      */
     public Long getLong() {
         return getValue().longValue();
     }
 
     /**
-     * Returns the current value as an Integer.
+     * Returns the current value as an {@link Integer}.
      *
-     * @return the current value as an Integer
+     * @return the current value as an {@link Integer}
      */
     public Integer getInteger() {
         return getValue().intValue();
@@ -332,7 +331,7 @@ public final class ChainedCalcUtil {
     }
 
     /**
-     * Converts the specified value to a BigDecimal.
+     * Converts the specified value to a {@link BigDecimal}.
      *
      * @param value the value to convert
      * @param scale the scale to apply to the resulting BigDecimal, or null if
diff --git a/devkit-utils/src/main/java/cn/org/codecrafters/devkit/utils/HashUtil.java b/devkit-utils/src/main/java/cn/org/codecrafters/devkit/utils/HashUtil.java
index e15892d..c12c9b1 100644
--- a/devkit-utils/src/main/java/cn/org/codecrafters/devkit/utils/HashUtil.java
+++ b/devkit-utils/src/main/java/cn/org/codecrafters/devkit/utils/HashUtil.java
@@ -25,12 +25,10 @@ import java.util.Objects;
 import java.util.Optional;
 
 /**
- * Utility class for performing hash operations on strings.
- * <p>
- * The HashUtil class provides convenient methods for calculating various hash
- * functions on strings, including MD2, MD5, SHA-1, SHA-224, SHA-256, SHA-384,
- * and SHA-512. It allows developers to easily obtain the hash value of a given
- * string using different algorithms.
+ * The {@code HashUtil} class provides convenient methods for calculating
+ * various hash functions on strings, including MD2, MD5, SHA-1, SHA-224,
+ * SHA-256, SHA-384, and SHA-512. It allows developers to easily obtain the
+ * hash value of a given string using different algorithms.
  * <p>
  * Example usage:
  * <pre>
@@ -55,8 +53,8 @@ import java.util.Optional;
  * // Perform SHA-512 hash operation
  * String sha512Hash = HashUtil.sha512("someString");
  * </pre>
- * The above examples demonstrate how to use the HashUtil class to calculate
- * hash values for a given string using different algorithms.
+ * The above examples demonstrate how to use the {@code HashUtil} class to
+ * calculate hash values for a given string using different algorithms.
  * <p>
  * <b>Note:</b>
  * The hash functions provided by the HashUtil class are one-way hash
diff --git a/devkit-utils/src/main/java/cn/org/codecrafters/devkit/utils/MapUtil.java b/devkit-utils/src/main/java/cn/org/codecrafters/devkit/utils/MapUtil.java
index d6e7644..ef54782 100644
--- a/devkit-utils/src/main/java/cn/org/codecrafters/devkit/utils/MapUtil.java
+++ b/devkit-utils/src/main/java/cn/org/codecrafters/devkit/utils/MapUtil.java
@@ -24,8 +24,8 @@ import java.util.HashMap;
 import java.util.Map;
 
 /**
- * MapUtil is a utility class that provides methods for converting objects to
- * maps and maps to objects.
+ * {@code MapUtil} is a utility class that provides methods for converting
+ * objects to maps and maps to objects.
  * <p>
  * It also provides methods for getting and setting field values using
  * reflection.
@@ -207,10 +207,10 @@ public final class MapUtil {
     /**
      * Casts the specified value to the required type.
      *
-     * @param value        the value to be casted
-     * @param requiredType the type to which the value should be casted
-     * @param <T>          the type to which the value should be casted
-     * @return the casted value, or null if the value cannot be casted to the
+     * @param value        the value to be cast
+     * @param requiredType the type to which the value should be cast
+     * @param <T>          the type to which the value should be cast
+     * @return the cast value, or null if the value cannot be cast to the
      * required type
      */
     public static <T> T cast(Object value, Class<T> requiredType) {
diff --git a/guid/src/main/java/cn/org/codecrafters/guid/SnowflakeGuidCreator.java b/guid/src/main/java/cn/org/codecrafters/guid/SnowflakeGuidCreator.java
index 78cd3bc..a20de90 100644
--- a/guid/src/main/java/cn/org/codecrafters/guid/SnowflakeGuidCreator.java
+++ b/guid/src/main/java/cn/org/codecrafters/guid/SnowflakeGuidCreator.java
@@ -24,12 +24,10 @@ import java.time.ZoneId;
 import java.time.ZoneOffset;
 
 /**
- * SnowflakeGuidCreator - GUID generator based on the Snowflake algorithm.
- * <p>
- * The SnowflakeGuidCreator generates unique identifiers using the Snowflake
- * algorithm, which combines a timestamp, worker ID, and data centre ID to
- * create 64-bit long integers. The bit distribution for the generated IDs is
- * as follows:
+ * The {@code SnowflakeGuidCreator} generates unique identifiers using the
+ * Snowflake algorithm, which combines a timestamp, worker ID, and data centre
+ * ID to create 64-bit long integers. The bit distribution for the generated
+ * IDs is as follows:
  * <ul>
  *     <li>1 bit for sign</li>
  *     <li>41 bits for timestamp (in milliseconds)</li>
@@ -38,10 +36,10 @@ import java.time.ZoneOffset;
  *     <li>12 bits for sequence number (per millisecond)</li>
  * </ul>
  * <p>
- * When initializing the SnowflakeGuidCreator, you must provide the worker ID
- * and data centre ID, ensuring they are within the valid range defined by the
- * bit size. The generator maintains an internal sequence number that
- * increments for IDs generated within the same millisecond. If the system
+ * When initializing a {@link SnowflakeGuidCreator}, you must provide the
+ * worker ID and data centre ID, ensuring they are within the valid range
+ * defined by the bit size. The generator maintains an internal sequence number
+ * that increments for IDs generated within the same millisecond. If the system
  * clock moves backward, an exception is thrown to prevent generating IDs with
  * repeated timestamps.
  *
diff --git a/guid/src/main/java/cn/org/codecrafters/guid/exceptions/TimingException.java b/guid/src/main/java/cn/org/codecrafters/guid/exceptions/TimingException.java
index feb1ed2..96a90ba 100644
--- a/guid/src/main/java/cn/org/codecrafters/guid/exceptions/TimingException.java
+++ b/guid/src/main/java/cn/org/codecrafters/guid/exceptions/TimingException.java
@@ -18,8 +18,8 @@
 package cn.org.codecrafters.guid.exceptions;
 
 /**
- * The TimingException class represents an exception that is thrown when there
- * is an error related to time sequence.
+ * The {@code TimingException} class represents an exception that is thrown
+ * when there is an error related to time sequence.
  * <p>
  * Instances of TimingException can be created with or without a message and a
  * cause. The message provides a description of the exception, while the cause
@@ -40,9 +40,9 @@ public class TimingException extends RuntimeException {
 
     /**
      * A custom exception that is thrown when there is an issue with timing or
-     * scheduling with customized error message.
+     * scheduling with customised error message.
      *
-     * @param message customized message
+     * @param message customised message
      */
     public TimingException(String message) {
         super(message);
@@ -50,9 +50,9 @@ public class TimingException extends RuntimeException {
 
     /**
      * A custom exception that is thrown when there is an issue with timing or
-     * scheduling with customized error message.
+     * scheduling with customised error message.
      *
-     * @param message customized message
+     * @param message customised message
      * @param cause   the cause of this exception
      */
     public TimingException(String message, Throwable cause) {
@@ -61,7 +61,7 @@ public class TimingException extends RuntimeException {
 
     /**
      * A custom exception that is thrown when there is an issue with timing or
-     * scheduling with customized error message.
+     * scheduling with customised error message.
      *
      * @param cause the cause of this exception
      */
diff --git a/property-guard-spring-boot-starter/README.md b/property-guard-spring-boot-starter/README.md
index 0c8d843..baf2be1 100644
--- a/property-guard-spring-boot-starter/README.md
+++ b/property-guard-spring-boot-starter/README.md
@@ -57,7 +57,7 @@ import cn.org.codecrafters.simplejwt.SecretCreator;
 
 class GenerateRandomKeySample {
     public static void main(String[] args) {
-        var secret1 = AesUtil.generateRandomKey();
+        var secret1 = AesUtil.generateRandomSecret();
         var secret2 = SecretCreator.createSecret(16, true, true, true);
     }
 }
diff --git a/property-guard-spring-boot-starter/src/main/java/cn/org/codecrafters/propertyguard/autoconfiguration/PropertyGuard.java b/property-guard-spring-boot-starter/src/main/java/cn/org/codecrafters/propertyguard/autoconfiguration/PropertyGuard.java
index 776cbdc..c2ca6fb 100644
--- a/property-guard-spring-boot-starter/src/main/java/cn/org/codecrafters/propertyguard/autoconfiguration/PropertyGuard.java
+++ b/property-guard-spring-boot-starter/src/main/java/cn/org/codecrafters/propertyguard/autoconfiguration/PropertyGuard.java
@@ -29,17 +29,27 @@ import java.util.HashMap;
 import java.util.Optional;
 
 /**
- * PropertyEncryptor is a utility class designed for encrypting configuration
- * information in Spring Boot applications.
+ * {@code PropertyGuard} is a utility class designed for encrypting
+ * configuration properties in Spring Boot applications.
  * <p>
  * Spring Boot applications often need to store sensitive configuration details
  * such as database passwords, API keys, etc. To ensure that these sensitive
- * pieces of information are not exposed, developers can utilize the
- * {@code PropertyGuard} class to encrypt and store them within configuration
- * files.
+ * pieces of information are not exposed to the public, developers can utilize
+ * the {@code PropertyGuard} class to encrypt and store them within
+ * configuration files.
  * <p>
  * <b>Usage</b>
- * In {@code application.yml} or {@code application.properties}:
+ * You need a 16-char long secret for encrypting a configuration property. You
+ * can get this secret on your own, or use the helper utility class by the
+ * following code:
+ * <pre>{@code
+ * var secret = AesUtil.generateRandomSecret(); // Let's presume the result is
+ *                                              // "3856faef0d2d4f33"
+ * }</pre>
+ * <p>
+ * Then, in {@code application.yml} or {@code application.properties}, change
+ * the original value from plain text to encrypted value with the prefix
+ * "<code>pg:</code>".
  * <pre>
  *     # original
  *     app.example-properties=Sample Value
@@ -47,16 +57,15 @@ import java.util.Optional;
  *     # encrypted with key 3856faef0d2d4f33
  *     app.example-properties=pg:t4YBfv8M9ZmTzWgTi2gJqg==
  * </pre>
- * Then, add the command line arguments like {@code --pe.key=3856faef0d2d4f33}.
+ * After that, before running, you need to add the command line arguments
+ * "pg.key" as the following codes: {@code --pg.key=<the secret>}.
  * <p>
  * This class is extracted from <a href="https://baomidou.com/pages/e0a5ce/"
  * >MyBatis-Plus</a>.
- * <p>
- * The prefix to specify the encrypted value is {@code pg}.
  *
  * @author hubin@baomidou
  * @version 1.1.0
- * @see org.springframework.boot.env.EnvironmentPostProcessor
+ * @see EnvironmentPostProcessor
  * @since 1.1.0 (3.3.2 of MyBatis-Plus)
  */
 public class PropertyGuard implements EnvironmentPostProcessor {
diff --git a/simple-jwt-authzero/src/main/java/cn/org/codecrafters/simplejwt/authzero/AuthzeroTokenResolver.java b/simple-jwt-authzero/src/main/java/cn/org/codecrafters/simplejwt/authzero/AuthzeroTokenResolver.java
index 653fd3b..01d3359 100644
--- a/simple-jwt-authzero/src/main/java/cn/org/codecrafters/simplejwt/authzero/AuthzeroTokenResolver.java
+++ b/simple-jwt-authzero/src/main/java/cn/org/codecrafters/simplejwt/authzero/AuthzeroTokenResolver.java
@@ -122,11 +122,11 @@ public class AuthzeroTokenResolver implements TokenResolver<DecodedJWT> {
     private final AuthzeroTokenResolverConfig config = AuthzeroTokenResolverConfig.getInstance();
 
     /**
-     * Creates a new instance of AuthzeroTokenResolver with the provided
-     * configurations.
+     * Creates a new instance of {@code AuthzeroTokenResolver} with the
+     * provided configurations.
      *
-     * @param jtiCreator the GuidCreator used for generating unique identifiers
-     *                   for "jti" claim in JWT tokens
+     * @param jtiCreator the {@link GuidCreator} used for generating unique
+     *                   identifiers for "jti" claim in JWT tokens
      * @param algorithm  the algorithm used for signing and verifying JWT
      *                   tokens
      * @param issuer     the issuer claim value to be included in JWT tokens
@@ -151,8 +151,8 @@ public class AuthzeroTokenResolver implements TokenResolver<DecodedJWT> {
     }
 
     /**
-     * Creates a new instance of AuthzeroTokenResolver with the provided
-     * configurations and a simple UUID GuidCreator.
+     * Creates a new instance of {@link AuthzeroTokenResolver} with the
+     * provided configurations and a simple UUID GuidCreator.
      *
      * @param algorithm the algorithm used for signing and verifying JWT tokens
      * @param issuer    the issuer claim value to be included in JWT tokens
@@ -168,7 +168,7 @@ public class AuthzeroTokenResolver implements TokenResolver<DecodedJWT> {
             log.warn("The provided secret which owns {} characters is too weak. Please consider replacing it with a stronger one.", secret.length());
         }
 
-        this.jtiCreator = (GuidCreator<UUID>) UUID::randomUUID;
+        this.jtiCreator = UUID::randomUUID;
         this.algorithm = config
                 .getAlgorithm(algorithm)
                 .apply(secret);
@@ -177,8 +177,9 @@ public class AuthzeroTokenResolver implements TokenResolver<DecodedJWT> {
     }
 
     /**
-     * Creates a new instance of AuthzeroTokenResolver with the provided
-     * configurations, HMAC256 algorithm and a simple UUID GuidCreator.
+     * Creates a new instance of {@link AuthzeroTokenResolver} with the
+     * provided configurations, HMAC256 algorithm and a simple
+     * UUID GuidCreator.
      *
      * @param issuer the issuer claim value to be included in JWT tokens
      * @param secret the secret used for HMAC-based algorithms (HS256,
@@ -193,7 +194,7 @@ public class AuthzeroTokenResolver implements TokenResolver<DecodedJWT> {
             log.warn("The provided secret which owns {} characters is too weak. Please consider replacing it with a stronger one.", secret.length());
         }
 
-        this.jtiCreator = (GuidCreator<UUID>) UUID::randomUUID;
+        this.jtiCreator = UUID::randomUUID;
         this.algorithm = config
                 .getAlgorithm(TokenAlgorithm.HS256)
                 .apply(secret);
@@ -202,15 +203,16 @@ public class AuthzeroTokenResolver implements TokenResolver<DecodedJWT> {
     }
 
     /**
-     * Creates a new instance of AuthzeroTokenResolver with the provided
-     * configurations, HMAC256 algorithm and a simple UUID GuidCreator.
+     * Creates a new instance of {@link AuthzeroTokenResolver} with the
+     * provided configurations, HMAC256 algorithm and a simple
+     * UUID GuidCreator.
      *
      * @param issuer the issuer claim value to be included in JWT tokens
      */
     public AuthzeroTokenResolver(String issuer) {
         var secret = SecretCreator.createSecret(32, true, true, true);
 
-        this.jtiCreator = (GuidCreator<UUID>) UUID::randomUUID;
+        this.jtiCreator = UUID::randomUUID;
         this.algorithm = config
                 .getAlgorithm(TokenAlgorithm.HS256)
                 .apply(secret);
@@ -286,16 +288,13 @@ public class AuthzeroTokenResolver implements TokenResolver<DecodedJWT> {
     }
 
     /**
-     * <p>
      * Builds the custom claims of the JSON Web Token (JWT) using the provided
      * Map of claims and adds them to the JWTCreator.Builder.
      * <p>
-     * <p>
      * This method is used to add custom claims to the JWT. It takes a Map of
      * claims, where each entry represents a custom claim name (key) and its
      * corresponding value (value). The custom claims will be added to the JWT
      * using the JWTCreator.Builder.
-     * <p>
      *
      * @param claims  a Map containing the custom claims to be added to the JWT
      * @param builder the JWTCreator.Builder instance to which the custom
@@ -310,9 +309,7 @@ public class AuthzeroTokenResolver implements TokenResolver<DecodedJWT> {
     }
 
     /**
-     * <p>
      * Finish creating a token.
-     *
      * <p>
      * This is the final step of create a token, to sign this token.
      *
@@ -324,7 +321,7 @@ public class AuthzeroTokenResolver implements TokenResolver<DecodedJWT> {
     }
 
     /**
-     * Creates a new token with the specified expiration time, subject, and
+     * Creates a new token with the specified expiration duration, subject, and
      * audience.
      *
      * @param expireAfter the duration after which the token will expire
@@ -387,7 +384,7 @@ public class AuthzeroTokenResolver implements TokenResolver<DecodedJWT> {
                 // Build Claims
                 addClaim(builder, field.getName(), field.get(payload));
             } catch (IllegalAccessException e) {
-                log.error("Cannot access field %s!".formatted(field.getName()));
+                log.error("Cannot access field {}!", field.getName());
             }
         }
 
@@ -395,10 +392,10 @@ public class AuthzeroTokenResolver implements TokenResolver<DecodedJWT> {
     }
 
     /**
-     * Resolves the given token into a DecodedJWT object.
+     * Resolves the given token into a {@link DecodedJWT} object.
      *
      * @param token the token to be resolved
-     * @return a ResolvedToken object
+     * @return a {@link DecodedJWT} object
      */
     @Override
     public DecodedJWT resolve(String token) {
@@ -449,9 +446,9 @@ public class AuthzeroTokenResolver implements TokenResolver<DecodedJWT> {
 
             return bean;
         } catch (NoSuchMethodException e) {
-            log.error("Unable to find a no-argument constructor declaration for class %s.".formatted(targetType.getCanonicalName()));
+            log.error("Unable to find a no-argument constructor declaration for class {}.", targetType.getCanonicalName());
         } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
-            log.error("Unable to create a new instance of class %s.".formatted(targetType.getCanonicalName()));
+            log.error("Unable to create a new instance of class {}.", targetType.getCanonicalName());
         }
         return null;
     }
@@ -475,7 +472,7 @@ public class AuthzeroTokenResolver implements TokenResolver<DecodedJWT> {
     /**
      * Renews the given expired token with the specified custom payload data.
      *
-     * @param oldToken the expired token to be renewed
+     * @param oldToken the expiring token to be renewed
      * @param payload  the custom payload data to be included in the renewed
      *                 token
      * @return the renewed token as a {@code String}
@@ -489,7 +486,7 @@ public class AuthzeroTokenResolver implements TokenResolver<DecodedJWT> {
      * Renews the given expired token with the new specified strongly-typed
      * payload data.
      *
-     * @param oldToken the expired token to be renewed
+     * @param oldToken the expiring token to be renewed
      * @param payload  the strongly-typed payload data to be included in the
      *                 renewed token
      * @return the renewed token as a {@code String}
@@ -511,7 +508,7 @@ public class AuthzeroTokenResolver implements TokenResolver<DecodedJWT> {
      * @param oldToken the expired token to be renewed
      * @param payload  the strongly-typed payload data to be included in the
      *                 renewed token
-     * @return the renewed token as a {@code String}
+     * @return the renewed token as a {@link String}
      */
     @Override
     public <T extends TokenPayload> String renew(String oldToken, T payload) {
diff --git a/simple-jwt-authzero/src/main/java/cn/org/codecrafters/simplejwt/authzero/config/AuthzeroTokenResolverConfig.java b/simple-jwt-authzero/src/main/java/cn/org/codecrafters/simplejwt/authzero/config/AuthzeroTokenResolverConfig.java
index 9377571..2cda8ea 100644
--- a/simple-jwt-authzero/src/main/java/cn/org/codecrafters/simplejwt/authzero/config/AuthzeroTokenResolverConfig.java
+++ b/simple-jwt-authzero/src/main/java/cn/org/codecrafters/simplejwt/authzero/config/AuthzeroTokenResolverConfig.java
@@ -17,6 +17,8 @@
 
 package cn.org.codecrafters.simplejwt.authzero.config;
 
+import cn.org.codecrafters.simplejwt.TokenResolver;
+import cn.org.codecrafters.simplejwt.authzero.AuthzeroTokenResolver;
 import cn.org.codecrafters.simplejwt.config.TokenResolverConfig;
 import cn.org.codecrafters.simplejwt.constants.TokenAlgorithm;
 import cn.org.codecrafters.simplejwt.exceptions.UnsupportedAlgorithmException;
@@ -29,29 +31,29 @@ import java.util.Optional;
 import java.util.function.Function;
 
 /**
- * The AuthzeroTokenResolverConfig class provides the configuration for the
- * AuthzeroTokenResolver.
+ * The {@code AuthzeroTokenResolverConfig} class provides the configuration for
+ * the {@link AuthzeroTokenResolver}.
  * <p>
- * This configuration class is used to establish the mapping between the
- * standard TokenAlgorithm defined within the AuthzeroTokenResolver facade and
- * the specific algorithms used by the Auth0 Java JWT library, which is the
- * underlying library used by AuthzeroTokenResolver to handle JSON Web Tokens
- * (JWTs).
+ * This configuration is used to establish the mapping between the standard
+ * {@link TokenAlgorithm} defined within the {@link AuthzeroTokenResolver}
+ * facade and the specific algorithms used by the {@code com.auth0:java-jwt}
+ * library, which is the underlying library used by {@link
+ * AuthzeroTokenResolver} to handle JSON Web Tokens (JWTs).
  * <p>
  * <b>Algorithm Mapping:</b>
- * The AuthzeroTokenResolverConfig class allows specifying the relationship
- * between the standard TokenAlgorithm instances supported by
- * AuthzeroTokenResolver and the corresponding algorithms used by the
- * com.auth0:java-jwt library. The mapping is achieved using a Map, where the
- * keys are the standard TokenAlgorithm instances, and the values represent the
- * algorithm functions used by Auth0 Java JWT library for each corresponding
- * key.
+ * The {@code AuthzeroTokenResolverConfig} allows specifying the relationship
+ * between the standard {@link TokenAlgorithm} instances supported by
+ * {@link AuthzeroTokenResolver} and the corresponding algorithms used by the
+ * {@code com.auth0:java-jwt} library. The mapping is achieved using a Map,
+ * where the keys are the standard TokenAlgorithm instances, and the values
+ * represent the algorithm functions used by Auth0 Java JWT library for each
+ * corresponding key.
  * <p>
  * <b>Note:</b>
  * The provided algorithm mapping should be consistent with the actual
- * algorithms supported and used by the Auth0 Java JWT library. It is crucial
- * to ensure that the mapping is accurate to enable proper token validation
- * and processing within the AuthzeroTokenResolver.
+ * algorithms supported and used by the {@code com.auth0:java-jwt} library. It
+ * is crucial to ensure that the mapping is accurate to enable proper token
+ * validation and processing within the {@link AuthzeroTokenResolver}.
  *
  * @author Zihlu Wang
  * @version 1.1.0
@@ -60,39 +62,34 @@ import java.util.function.Function;
 public final class AuthzeroTokenResolverConfig implements TokenResolverConfig<Function<String, Algorithm>> {
 
     /**
-     * <p>
-     * Constructs a new instance of AuthzeroTokenResolverConfig.
-     *
+     * Constructs a new instance of {@code AuthzeroTokenResolverConfig}.
      * <p>
      * The constructor is set as private to enforce the singleton pattern for
-     * this configuration class. Instances of AuthzeroTokenResolverConfig
-     * should be obtained through the {@link #getInstance()} method.
+     * this configuration class. Instances of
+     * {@code AuthzeroTokenResolverConfig} should be obtained through the
+     * {@link #getInstance()} method.
      */
     private AuthzeroTokenResolverConfig() {
     }
 
     /**
-     * <p>
-     * The singleton instance of AuthzeroTokenResolverConfig.
-     *
+     * The singleton instance of {@code AuthzeroTokenResolverConfig}.
      * <p>
      * This instance is used to ensure that only one instance of
-     * AuthzeroTokenResolverConfig is created and shared throughout the
-     * application. The singleton pattern is implemented to provide centralized
+     * {@code AuthzeroTokenResolverConfig} is created and shared throughout the
+     * application. The singleton pattern is implemented to provide centralised
      * configuration and avoid redundant object creation.
      */
     private static AuthzeroTokenResolverConfig instance;
 
     /**
-     * <p>
      * The supported algorithms and their corresponding algorithm functions.
-     *
      * <p>
      * This map stores the supported algorithms as keys and their corresponding
      * algorithm functions as values. The algorithm functions represent the
-     * functions used by the Auth0 Java JWT library to handle the specific
-     * algorithms. The mapping is used to provide proper algorithm resolution
-     * and processing within the AuthzeroTokenResolver.
+     * functions used by the {@code com.auth0:java-jwt} library to handle the
+     * specific algorithms. The mapping is used to provide proper algorithm
+     * resolution and processing within the {@link AuthzeroTokenResolver}.
      */
     private static final Map<TokenAlgorithm, Function<String, Algorithm>> SUPPORTED_ALGORITHMS = new HashMap<>() {{
         put(TokenAlgorithm.HS256, Algorithm::HMAC256);
@@ -101,14 +98,14 @@ public final class AuthzeroTokenResolverConfig implements TokenResolverConfig<Fu
     }};
 
     /**
-     * Gets the instance of AuthzeroTokenResolverConfig.
+     * Gets the instance of {@code AuthzeroTokenResolverConfig}.
      * <p>
      * This method returns the singleton instance of
-     * AuthzeroTokenResolverConfig. If the instance is not yet created, it will
-     * create a new instance and return it. Otherwise, it returns the existing
-     * instance.
+     * {@code AuthzeroTokenResolverConfig}. If the instance is not yet created,
+     * it will create a new instance and return it. Otherwise, it returns the
+     * existing instance.
      *
-     * @return the instance of AuthzeroTokenResolverConfig
+     * @return the instance of {@code AuthzeroTokenResolverConfig}
      */
     public static AuthzeroTokenResolverConfig getInstance() {
         if (Objects.isNull(instance)) {
@@ -119,20 +116,20 @@ public final class AuthzeroTokenResolverConfig implements TokenResolverConfig<Fu
     }
 
     /**
-     * <p>
      * Gets the algorithm function corresponding to the specified
-     * TokenAlgorithm.
-     *
+     * {@link TokenAlgorithm}.
      * <p>
      * This method returns the algorithm function associated with the given
-     * TokenAlgorithm. The provided TokenAlgorithm represents the specific
-     * algorithm for which the corresponding algorithm function is required.
-     * The returned AlgorithmFunction represents the function implementation
-     * that can be used by the TokenResolver to handle the specific algorithm.
+     * {@link TokenAlgorithm}. The provided {@link TokenAlgorithm} represents
+     * the specific algorithm for which the corresponding algorithm function
+     * is required. The returned Algorithm Function represents the function
+     * implementation that can be used by the {@link TokenResolver} to handle
+     * the specific algorithm.
      *
-     * @param algorithm the TokenAlgorithm for which the algorithm function is
-     *                  required
-     * @return the algorithm function associated with the given TokenAlgorithm
+     * @param algorithm the {@link TokenAlgorithm} for which the algorithm
+     *                  function isrequired
+     * @return the algorithm function associated with the given {@link
+     * TokenAlgorithm}
      * @throws UnsupportedAlgorithmException if the given {@code algorithm} is
      *                                       not supported by this
      *                                       implementation
diff --git a/simple-jwt-authzero/src/main/java/cn/org/codecrafters/simplejwt/authzero/package-info.java b/simple-jwt-authzero/src/main/java/cn/org/codecrafters/simplejwt/authzero/package-info.java
index c8ba91c..11df0aa 100644
--- a/simple-jwt-authzero/src/main/java/cn/org/codecrafters/simplejwt/authzero/package-info.java
+++ b/simple-jwt-authzero/src/main/java/cn/org/codecrafters/simplejwt/authzero/package-info.java
@@ -33,18 +33,21 @@
  * main token resolver in the Simple JWT project when integrating {@code
  * com.auth0:java-jwt} as the JWT management library.
  * <p>
- * The {@code AuthzeroTokenResolver} relies on the {@code com.auth0:java-jwt}
- * library to handle the underlying JWT operations, including token creation,
- * validation, and extraction. It utilizes the {@code com.auth0:java-jwt}
- * {@code Algorithm} class to define and use different algorithms for JWT
- * signing and verification.
+ * The {@link cn.org.codecrafters.simplejwt.authzero.AuthzeroTokenResolver}
+ * relies on the {@code com.auth0:java-jwt} library to handle the underlying
+ * JWT operations, including token creation, validation, and extraction. It
+ * utilizes the {@code com.auth0:java-jwt} {@link
+ * com.auth0.jwt.algorithms.Algorithm} class to define and use different
+ * algorithms for JWT signing and verification.
  * <p>
- * To use the {@code AuthzeroTokenResolver}, developers must provide the
- * necessary configurations and dependencies, such as the {@code GuidCreator}
- * for generating unique JWT IDs (JTI), the supported algorithm function, the
- * issuer name, and the secret key used for token signing and validation. The
- * {@code AuthzeroTokenResolverConfig} class provides a convenient way to
- * configure these dependencies.
+ * To use the {@link
+ * cn.org.codecrafters.simplejwt.authzero.AuthzeroTokenResolver}, developers
+ * must provide the necessary configurations and dependencies, such as the
+ * {@link cn.org.codecrafters.guid.GuidCreator} for generating unique JWT IDs
+ * (JTI), the supported algorithm function, the issuer name, and the secret key
+ * used for token signing and validation. The {@link
+ * cn.org.codecrafters.simplejwt.authzero.config.AuthzeroTokenResolverConfig}
+ * class provides a convenient way to configure these dependencies.
  * <p>
  * Developers using the {@code com.auth0:java-jwt} integration should be
  * familiar with the concepts and usage of the {@code com.auth0:java-jwt}
diff --git a/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/SecretCreator.java b/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/SecretCreator.java
index de06136..4f274ec 100644
--- a/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/SecretCreator.java
+++ b/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/SecretCreator.java
@@ -22,9 +22,9 @@ import cn.org.codecrafters.simplejwt.exceptions.WeakSecretException;
 import java.util.Random;
 
 /**
- * SecretCreator is a utility class that provides methods to generate secure
- * secret strings. The generated secrets can be used as cryptographic keys or
- * passwords for various security-sensitive purposes.
+ * {@code SecretCreator} is a utility class that provides methods to generate
+ * secure secret strings. The generated secrets can be used as cryptographic
+ * keys or passwords for various security-sensitive purposes.
  *
  * @author Zihlu Wang
  * @version 1.1.0
@@ -83,24 +83,23 @@ public final class SecretCreator {
         if (length < 32) {
             throw new WeakSecretException("""
                     The requested secret, which is only %d characters long, is too weak. \
-                    Please replace it with a stronger secret.
-                    """.formatted(length));
+                    Please replace it with a stronger secret.""".formatted(length));
         }
 
-        final var randomizer = new Random();
+        final var randomiser = new Random();
         var charset = new StringBuilder(LOWERCASE_CHARACTERS);
 
         if (isContainCapital) charset.append(UPPERCASE_CHARACTERS);
         if (isContainDigital) charset.append(DIGITS);
         if (isContainSpecialSign) charset.append(SPECIAL_SIGNS);
 
-        var password = new StringBuilder();
+        var secretBuilder = new StringBuilder();
         var charsetSize = charset.length();
         for (var i = 0; i < length; ++i) {
-            password.append(charset.charAt(randomizer.nextInt(charsetSize)));
+            secretBuilder.append(charset.charAt(randomiser.nextInt(charsetSize)));
         }
 
-        return password.toString();
+        return secretBuilder.toString();
     }
 
     /**
@@ -115,6 +114,7 @@ public final class SecretCreator {
      * @return the generated secure secret
      * @throws WeakSecretException if the requested secret length is less than
      *                             32 characters
+     * @see #createSecret(int, boolean, boolean, boolean)
      */
     public static String createSecret(int length,
                                       boolean isContainCapital,
@@ -132,6 +132,7 @@ public final class SecretCreator {
      * @return the generated secure secret
      * @throws WeakSecretException if the requested secret length is less than
      *                             32 characters
+     * @see #createSecret(int, boolean, boolean, boolean)
      */
     public static String createSecret(int length,
                                       boolean isContainCapital) {
@@ -146,6 +147,7 @@ public final class SecretCreator {
      * @return the generated secure secret
      * @throws WeakSecretException if the requested secret length is less than
      *                             32 characters
+     * @see #createSecret(int, boolean, boolean, boolean)
      */
     public static String createSecret(int length) {
         return createSecret(length, false, false, false);
diff --git a/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/TokenPayload.java b/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/TokenPayload.java
index e69a480..657e83c 100644
--- a/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/TokenPayload.java
+++ b/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/TokenPayload.java
@@ -20,21 +20,15 @@ package cn.org.codecrafters.simplejwt;
 import java.util.Map;
 
 /**
- * <p>
- * TokenPayload - Interface for JWT Payload Data Classes.
- *
- * <p>
- * The {@code TokenPayload} interface is used to mark a data class as suitable
+ * {@code TokenPayload} interface is used to mark a data class as suitable
  * for being used as the payload in a JSON Web Token (JWT). Any class
  * implementing this interface can be used to represent the payload data that
  * will be included in a JWT.
- *
  * <p>
  * Implementing this interface indicates that the data class contains
  * information that needs to be securely transmitted and verified as part of a
  * JWT. The payload typically contains claims or attributes that provide
  * additional information about the JWT subject or context.
- *
  * <p>
  * <b>Usage:</b>
  * To use a class as a JWT payload, simply implement the {@code TokenPayload}
diff --git a/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/TokenResolver.java b/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/TokenResolver.java
index 17fcce4..c69818d 100644
--- a/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/TokenResolver.java
+++ b/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/TokenResolver.java
@@ -22,10 +22,10 @@ import java.time.Duration;
 import java.util.Map;
 
 /**
- * The {@code TokenResolver} interface defines methods for creating,
- * extracting, and renewing tokens, particularly JSON Web Tokens (JWTs). It
- * provides a set of methods to generate tokens with various payload
- * configurations, extract payload from tokens, and renew expired tokens.
+ * {@code TokenResolver}  defines methods for creating, extracting, and
+ * renewing tokens, particularly JSON Web Tokens (JWTs). It provides a set of
+ * methods to generate tokens with various payload configurations, extract
+ * payload from tokens, and renew expired tokens.
  * <p>
  * <b>Token Creation:</b>
  * The interface provides overloaded methods for creating tokens with different
diff --git a/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/annotations/ExcludeFromPayload.java b/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/annotations/ExcludeFromPayload.java
index 2aa1450..72dac57 100644
--- a/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/annotations/ExcludeFromPayload.java
+++ b/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/annotations/ExcludeFromPayload.java
@@ -23,11 +23,10 @@ import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
 /**
- * <p>
- * This annotation is used to mark a property of a data class that should be
- * excluded from being automatically injected into the JSON Web Token (JWT)
- * payload during token generation. When a property is annotated with this
- * annotation, it will not be included as part of the JWT payload.
+ * Annotation {@code ExcludeFromPayload} is used to mark a property of a data
+ * class that should be excluded from being automatically injected into the
+ * JSON Web Token (JWT) payload during token generation. When a property is
+ * annotated by this annotation, it will not be included in the JWT payloads.
  * <p>
  * <b>Usage:</b>
  * To exclude a property from the JWT payload, annotate the property with
@@ -46,10 +45,10 @@ import java.lang.annotation.Target;
  * }</pre>
  * <p>
  * <b>Note:</b>
- * This annotation should be used only on properties that are not intended to
+ * This annotation should be used on properties that are not intended to
  * be included in the JWT payload due to their sensitive nature or for other
- * reasons. It is important to carefully choose which properties are excluded
- * from the payload to ensure the JWT remains secure and efficient.
+ * reasons only. It is important to carefully choose which properties are
+ * excluded from the payload to ensure the JWT remains secure and efficient.
  *
  * @author Zihlu Wang
  * @version 1.1.0
diff --git a/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/config/TokenResolverConfig.java b/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/config/TokenResolverConfig.java
index da64e21..2989a03 100644
--- a/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/config/TokenResolverConfig.java
+++ b/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/config/TokenResolverConfig.java
@@ -17,19 +17,21 @@
 
 package cn.org.codecrafters.simplejwt.config;
 
+import cn.org.codecrafters.simplejwt.TokenResolver;
 import cn.org.codecrafters.simplejwt.constants.TokenAlgorithm;
 
 /**
- * The TokenResolverConfig interface provides a mechanism to configure a
- * TokenResolver with algorithm functions.
+ * The {@code TokenResolverConfig} provides a mechanism to configure a
+ * {@link TokenResolver} with algorithm functions.
  * <p>
  * This generic interface is used to define the configuration details for a
- * TokenResolver that utilizes algorithm functions. The interface allows for
- * specifying algorithm functions corresponding to different TokenAlgorithm
- * instances supported by the TokenResolver implementation.
+ * {@link TokenResolver} that utilizes algorithm functions. The interface
+ * allows for specifying algorithm functions corresponding to different {@link
+ * TokenAlgorithm} instances supported by the {@link TokenResolver}
+ * implementation.
  *
  * @param <Algo> the type representing algorithm functions used by the
- *               {@code TokenResolver}
+ *               {@link TokenResolver}
  * @author Zihlu Wang
  * @version 1.0.0
  * @since 1.0.0
@@ -37,18 +39,20 @@ import cn.org.codecrafters.simplejwt.constants.TokenAlgorithm;
 public interface TokenResolverConfig<Algo> {
 
     /**
-     * Gets the algorithm function corresponding to the specified
-     * TokenAlgorithm.
+     * Gets the algorithm function corresponding to the specified {@link
+     * TokenAlgorithm}.
      * <p>
      * This method returns the algorithm function associated with the given
-     * TokenAlgorithm. The provided TokenAlgorithm represents the specific
-     * algorithm for which the corresponding algorithm function is required.
-     * The returned AlgorithmFunction represents the function implementation
-     * that can be used by the TokenResolver to handle the specific algorithm.
+     * {@link TokenAlgorithm}. The provided TokenAlgorithm represents the
+     * specific algorithm for which the corresponding algorithm function is
+     * required. The returned {@code Algo} represents the function
+     * implementation that can be used by the {@link TokenResolver} to handle
+     * the specific algorithm.
      *
-     * @param algorithm the TokenAlgorithm for which the algorithm function is
-     *                  required
-     * @return the algorithm function associated with the given TokenAlgorithm
+     * @param algorithm the {@link TokenAlgorithm} for which the algorithm
+     *                  function is required
+     * @return the algorithm function associated with the given {@link
+     * TokenAlgorithm}
      */
     Algo getAlgorithm(TokenAlgorithm algorithm);
 
diff --git a/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/config/package-info.java b/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/config/package-info.java
index 0fa35ff..97774c4 100644
--- a/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/config/package-info.java
+++ b/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/config/package-info.java
@@ -17,14 +17,15 @@
 
 /**
  * The classes in this package provide configuration options and settings for
- * the Simple JWT library. They are used to customize the behavior of the
- * library and allow developers to fine-tune various aspects of JWT generation
- * and validation.
+ * the {@code cn.org.codecrafters:simple-jwt-facade} library. They are used
+ * to customize the behavior of the library and allow developers to fine-tune
+ * various aspects of JWT generation and validation.
  * <p>
  * Other configuration classes may be added in the future to support additional
- * customisation options and features. Developers using the Simple JWT library
- * should be familiar with the available configuration options to ensure proper
- * integration and usage of the library.
+ * customisation options and features. Developers using the
+ * {@code cn.org.codecrafters:simple-jwt-facade} library should be familiar
+ * with the available configuration options to ensure proper integration and
+ * usage of the library.
  *
  * @since 1.0.0
  */
diff --git a/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/constants/PredefinedKeys.java b/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/constants/PredefinedKeys.java
index 467869b..3aee4db 100644
--- a/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/constants/PredefinedKeys.java
+++ b/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/constants/PredefinedKeys.java
@@ -87,11 +87,13 @@ public final class PredefinedKeys {
     public static final List<String> KEYS = List.of(ISSUER, SUBJECT, AUDIENCE, EXPIRATION_TIME, NOT_BEFORE, ISSUED_AT, JWT_ID);
 
     /**
-     * Private constructor to prevent instantiation of the {@code PredefinedKeys} class.
-     * This class is intended to be used as a utility class with only static constants and methods.
+     * Private constructor to prevent instantiation of the
+     * {@code PredefinedKeys} class.
+     * <p>
+     * This class is intended to be used as a utility class with only static
+     * constants and methods.
      */
     private PredefinedKeys() {
-        // Private constructor to prevent instantiation
     }
 }
 
diff --git a/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/constants/TokenAlgorithm.java b/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/constants/TokenAlgorithm.java
index c790306..4725089 100644
--- a/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/constants/TokenAlgorithm.java
+++ b/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/constants/TokenAlgorithm.java
@@ -25,8 +25,8 @@ import lombok.Getter;
  * cryptographic algorithms to be used for secure token generation and
  * validation. This enum provides a list of supported algorithms to ensure
  * consistent usage and avoid potential security issues.
- * <p><b>Supported Algorithms:</b>
- * This enum includes the following supported algorithms:
+ * <p>
+ * <b>Supported Algorithms:</b>
  * <ul>
  *     <li>{@link TokenAlgorithm#HS256}: HMAC SHA-256</li>
  *     <li>{@link TokenAlgorithm#HS384}: HMAC SHA-384</li>
diff --git a/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/exceptions/UnsupportedAlgorithmException.java b/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/exceptions/UnsupportedAlgorithmException.java
index 1ddb111..020ea63 100644
--- a/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/exceptions/UnsupportedAlgorithmException.java
+++ b/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/exceptions/UnsupportedAlgorithmException.java
@@ -18,10 +18,15 @@
 package cn.org.codecrafters.simplejwt.exceptions;
 
 /**
- * This {@code UnsupportedAlgorithmException} is to indicates that the given
- * algorithm is not supported by TokenResolver yet.
+ * This {@code UnsupportedAlgorithmException} represents the given
+ * algorithm is not supported by {@link
+ * cn.org.codecrafters.simplejwt.TokenResolver} yet.
  * <p>
- * To support a specified algorithm, you could
+ * If you want the supports to an unsupported algorithm, you could
+ * <ul>
+ *     <li>Commit an issue at GitHub Issues or;</li>
+ *     <li>Communicate with us on Discord Community.</li>
+ * </ul>
  *
  * @author Zihlu Wang
  * @version 1.1.0
@@ -30,17 +35,17 @@ package cn.org.codecrafters.simplejwt.exceptions;
 public class UnsupportedAlgorithmException extends RuntimeException {
 
     /**
-     * Constructs a new runtime exception with {@code null} as its detail
-     * message. The cause is not initialized, and may subsequently be
-     * initialized by a call to {@link #initCause}.
+     * Constructs a new {@code UnsupportedAlgorithmException} with {@code null}
+     * as its detail message. The cause is not initialized, and may
+     * subsequently be initialized by a call to {@link #initCause}.
      */
     public UnsupportedAlgorithmException() {
     }
 
     /**
-     * Constructs a new runtime exception with the specified detail message.
-     * The cause is not initialized, and may subsequently be initialized by a
-     * call to {@link #initCause}.
+     * Constructs a new {@code UnsupportedAlgorithmException} with the
+     * specified detail message. The cause is not initialized, and may
+     * subsequently be initialized by a call to {@link #initCause}.
      *
      * @param message the detail message. The detail message is saved for
      *                later retrieval by the {@link #getMessage()} method.
@@ -50,12 +55,8 @@ public class UnsupportedAlgorithmException extends RuntimeException {
     }
 
     /**
-     * Constructs a new runtime exception with the specified detail message and
-     * cause.
-     * <p>
-     * Note that the detail message associated with
-     * {@code cause} is <i>not</i> automatically incorporated in
-     * this runtime exception's detail message.
+     * Constructs a new {@code UnsupportedAlgorithmException} with the
+     * specified detail message and cause.
      *
      * @param message the detail message (which is saved for later retrieval
      *                by the {@link #getMessage()} method).
@@ -70,11 +71,12 @@ public class UnsupportedAlgorithmException extends RuntimeException {
     }
 
     /**
-     * Constructs a new runtime exception with the specified cause and a
-     * detail message of {@code (cause==null ? null : cause.toString())}
-     * (which typically contains the class and detail message of
-     * {@code cause}).  This constructor is useful for runtime exceptions
-     * that are little more than wrappers for other throwables.
+     * Constructs a new {@code UnsupportedAlgorithmException} with the
+     * specified cause and a detail message of
+     * {@code (cause==null ? null : cause.toString())} (which typically
+     * contains the class and detail message of {@code cause}).  This
+     * constructor is useful for runtime exceptions that are little more
+     * than wrappers for other throwable.
      *
      * @param cause the cause (which is saved for later retrieval by the
      *              {@link #getCause()} method).  (A {@code null} value is
@@ -87,9 +89,9 @@ public class UnsupportedAlgorithmException extends RuntimeException {
     }
 
     /**
-     * Constructs a new runtime exception with the specified detail
-     * message, cause, suppression enabled or disabled, and writable
-     * stack trace enabled or disabled.
+     * Constructs a new {@code UnsupportedAlgorithmException} with the
+     * specified detail message, cause, suppression enabled or disabled, and
+     * writable stack trace enabled or disabled.
      *
      * @param message            the detail message.
      * @param cause              the cause (A {@code null} value is permitted,
diff --git a/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/exceptions/WeakSecretException.java b/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/exceptions/WeakSecretException.java
index bc46ec6..25126f9 100644
--- a/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/exceptions/WeakSecretException.java
+++ b/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/exceptions/WeakSecretException.java
@@ -18,8 +18,12 @@
 package cn.org.codecrafters.simplejwt.exceptions;
 
 /**
- * This Exception indicates that your secret is too weak to be used in signing
- * JWTs.
+ * {@code WeakSecretException} represents that your secret is too weak to be
+ * used in signing JWTs.
+ * <p>
+ * {@code WeakSecretException} will only appears that if you are using the
+ * implementation module {@code cn.org.codecrafters:simple-jwt-jjwt} due to
+ * it is implemented by {@code io.jsonwebtoken:jjwt}.
  *
  * @author Zihlu Wang
  * @version 1.1.0
@@ -28,17 +32,17 @@ package cn.org.codecrafters.simplejwt.exceptions;
 public class WeakSecretException extends RuntimeException {
 
     /**
-     * Constructs a new runtime exception with {@code null} as its
-     * detail message.  The cause is not initialized, and may subsequently be
+     * Constructs a new {@code WeakSecretException} with {@code null} as its
+     * detail message. The cause is not initialized, and may subsequently be
      * initialized by a call to {@link #initCause}.
      */
     public WeakSecretException() {
     }
 
     /**
-     * Constructs a new runtime exception with the specified detail message.
-     * The cause is not initialized, and may subsequently be initialized by a
-     * call to {@link #initCause}.
+     * Constructs a new {@code WeakSecretException} with the specified detail
+     * message. The cause is not initialized, and may subsequently be
+     * initialized by a call to {@link #initCause}.
      *
      * @param message the detail message. The detail message is saved for
      *                later retrieval by the {@link #getMessage()} method.
@@ -48,10 +52,11 @@ public class WeakSecretException extends RuntimeException {
     }
 
     /**
-     * Constructs a new runtime exception with the specified detail message and
-     * cause.  <p>Note that the detail message associated with
-     * {@code cause} is <i>not</i> automatically incorporated in
-     * this runtime exception's detail message.
+     * Constructs a new {@code WeakSecretException} with the specified detail
+     * message and cause.
+     * <p>
+     * Note that the detail message associated with {@code cause} is <i>not</i>
+     * automatically incorporated in this runtime exception's detail message.
      *
      * @param message the detail message (which is saved for later retrieval
      *                by the {@link #getMessage()} method).
@@ -59,42 +64,41 @@ public class WeakSecretException extends RuntimeException {
      *                {@link #getCause()} method).  (A {@code null} value is
      *                permitted, and indicates that the cause is nonexistent or
      *                unknown.)
-     * @since 1.4
+     * @since 1.0.0
      */
     public WeakSecretException(String message, Throwable cause) {
         super(message, cause);
     }
 
     /**
-     * Constructs a new runtime exception with the specified cause and a
-     * detail message of {@code (cause==null ? null : cause.toString())}
+     * Constructs a new {@code WeakSecretException} with the specified cause
+     * and a detail message of {@code (cause==null ? null : cause.toString())}
      * (which typically contains the class and detail message of
-     * {@code cause}).  This constructor is useful for runtime exceptions
-     * that are little more than wrappers for other throwables.
+     * {@code cause}). This constructor is useful for runtime exceptions that
+     * are little more than wrappers for other throwable.
      *
      * @param cause the cause (which is saved for later retrieval by the
      *              {@link #getCause()} method).  (A {@code null} value is
      *              permitted, and indicates that the cause is nonexistent or
      *              unknown.)
-     * @since 1.4
+     * @since 1.0.0
      */
     public WeakSecretException(Throwable cause) {
         super(cause);
     }
 
     /**
-     * Constructs a new runtime exception with the specified detail
+     * Constructs a new {@code WeakSecretException} with the specified detail
      * message, cause, suppression enabled or disabled, and writable
      * stack trace enabled or disabled.
      *
      * @param message            the detail message.
-     * @param cause              the cause.  (A {@code null} value is permitted,
-     *                           and indicates that the cause is nonexistent or unknown.)
-     * @param enableSuppression  whether or not suppression is enabled
-     *                           or disabled
-     * @param writableStackTrace whether or not the stack trace should
-     *                           be writable
-     * @since 1.7
+     * @param cause              the cause. (A {@code null} value is permitted,
+     *                           and indicates that the cause is nonexistent or
+     *                           unknown.)
+     * @param enableSuppression  whether suppression is enabled or disabled
+     * @param writableStackTrace whether the stack trace should be writable
+     * @since 1.0.0
      */
     public WeakSecretException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
         super(message, cause, enableSuppression, writableStackTrace);
diff --git a/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/exceptions/package-info.java b/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/exceptions/package-info.java
index 470140c..b8f48f8 100644
--- a/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/exceptions/package-info.java
+++ b/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/exceptions/package-info.java
@@ -17,20 +17,22 @@
 
 /**
  * The {@code cn.org.codecrafters.simplejwt.exceptions} package contains
- * custom exception classes related to the Simple JWT library. These
- * exceptions are thrown when there are issues or errors during the generation
- * , validation, or processing of JSON Web Tokens (JWTs) in Java applications.
+ * custom exception classes related to the
+ * {@code cn.org.codecrafters:simple-jwt-facade} library. These exceptions are
+ * thrown when there are issues or errors during the generation , validation,
+ * or processing of JSON Web Tokens (JWTs) in Java applications.
  * <p>
  * Custom exception classes in this package are designed to enhance the
  * robustness and reliability of the JWT handling process by providing clear
  * and meaningful error messages to the developers. They help developers
  * identify and troubleshoot issues related to JWT generation, validation, or
- * extraction and ensure smooth operation and error handling in their
- * applications.
+ * extraction and ensure smooth operation and error handling in
+ * their applications.
  * <p>
- * Developers using the Simple JWT library should be aware of the possible
- * exceptions that can be thrown and handle them appropriately to ensure secure
- * and reliable JWT handling in their Java applications.
+ * Developers using the {@code cn.org.codecrafters:simple-jwt-facade} library
+ * should be aware of the possible exceptions that can be thrown and handle
+ * them appropriately to ensure secure and reliable JWT handling in their
+ * Java applications.
  *
  * @since 1.0.0
  */
diff --git a/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/package-info.java b/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/package-info.java
index 490200b..791dae8 100644
--- a/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/package-info.java
+++ b/simple-jwt-facade/src/main/java/cn/org/codecrafters/simplejwt/package-info.java
@@ -17,22 +17,22 @@
 
 /**
  * The {@code cn.org.codecrafters.simplejwt} package is the core package of the
- * Simple JWT project, which provides a lightweight and easy-to-use library for
- * working with JSON Web Tokens (JWTs) in Java applications. JWT is a
- * widely-used standard for representing claims between two parties, typically
- * used to secure web and mobile applications. This library aims to simplify
- * the JWT handling process and provide convenient abstractions for JWT
- * generation, validation, and extraction.
+ * <b>Simple JWT</b> project, which provides a lightweight and easy-to-use
+ * library for working with JSON Web Tokens (JWTs) in Java applications. JWT is
+ * a widely-used standard for representing claims between two parties,
+ * typically used to secure web and mobile applications. This library aims to
+ * simplify the JWT handling process and provide convenient abstractions for
+ * JWT generation, validation, and extraction.
  * <p>
- * The Simple JWT library is designed to be flexible and customisable, allowing
- * developers to use different algorithms, token resolvers, and token payload
- * classes based on their specific application requirements. It aims to
+ * The <b>Simple JWT</b> library is designed to be flexible and customisable,
+ * allowing developers to use different algorithms, token resolvers, and token
+ * payload classes based on their specific application requirements. It aims to
  * simplify the JWT handling process while maintaining security and best
  * practices for working with JWTs.
  * <p>
  * Developers should refer to the official documentation and examples for the
- * Simple JWT project to understand how to use the library effectively and
- * securely in their Java applications.
+ * <b>Simple JWT</b> project to understand how to use the library effectively
+ * and securely in their Java applications.
  * 
  *
  * @since 1.0.0
diff --git a/simple-jwt-jjwt/src/main/java/cn/org/codecrafters/simplejwt/jjwt/JjwtTokenResolver.java b/simple-jwt-jjwt/src/main/java/cn/org/codecrafters/simplejwt/jjwt/JjwtTokenResolver.java
index fc9f4e8..b8896ef 100644
--- a/simple-jwt-jjwt/src/main/java/cn/org/codecrafters/simplejwt/jjwt/JjwtTokenResolver.java
+++ b/simple-jwt-jjwt/src/main/java/cn/org/codecrafters/simplejwt/jjwt/JjwtTokenResolver.java
@@ -58,7 +58,7 @@ import java.util.UUID;
  * To use the {@code JjwtTokenResolver}, first, create an instance of this
  * class:
  * <pre>{@code
- *   TokenResolver<DecodedJWT> tokenResolver =
+ *   TokenResolver<Jws<Claims>> tokenResolver =
  *       new JjwtTokenResolver(TokenAlgorithm.HS256,
  *                                 "Token Subject",
  *                                 "Token Issuer",
@@ -119,7 +119,7 @@ public class JjwtTokenResolver implements TokenResolver<Jws<Claims>> {
 
         if (secret.length() <= 32) {
             log.error("""
-                            The provided secret which owns {} characters is too weak. Please replace it with a stronger one.""",
+                      The provided secret which owns {} characters is too weak. Please replace it with a stronger one.""",
                     secret.length());
             throw new WeakSecretException("""
                     The provided secret which owns %s characters is too weak. Please replace it with a stronger one."""
@@ -256,7 +256,7 @@ public class JjwtTokenResolver implements TokenResolver<Jws<Claims>> {
     }
 
     /**
-     * Resolves the given token into a ResolvedTokenType object.
+     * Resolves the given token into a {@link Jws<Claims>} object.
      *
      * @param token the token to be resolved
      * @return a ResolvedTokenType object
@@ -287,7 +287,7 @@ public class JjwtTokenResolver implements TokenResolver<Jws<Claims>> {
         try {
             return MapUtil.mapToObject(claims, targetType);
         } catch (InvocationTargetException e) {
-            log.info("An error occurs while invoking the constructor of type {}.", targetType.getCanonicalName());
+            log.error("An error occurs while invoking the constructor of type {}.", targetType.getCanonicalName());
         } catch (NoSuchMethodException e) {
             log.error("The constructor of the required type {} is not found.", targetType.getCanonicalName());
         } catch (InstantiationException e) {
diff --git a/simple-jwt-jjwt/src/main/java/cn/org/codecrafters/simplejwt/jjwt/config/JjwtTokenResolverConfig.java b/simple-jwt-jjwt/src/main/java/cn/org/codecrafters/simplejwt/jjwt/config/JjwtTokenResolverConfig.java
index adf118f..a174665 100644
--- a/simple-jwt-jjwt/src/main/java/cn/org/codecrafters/simplejwt/jjwt/config/JjwtTokenResolverConfig.java
+++ b/simple-jwt-jjwt/src/main/java/cn/org/codecrafters/simplejwt/jjwt/config/JjwtTokenResolverConfig.java
@@ -17,6 +17,7 @@
 
 package cn.org.codecrafters.simplejwt.jjwt.config;
 
+import cn.org.codecrafters.simplejwt.TokenResolver;
 import cn.org.codecrafters.simplejwt.config.TokenResolverConfig;
 import cn.org.codecrafters.simplejwt.constants.TokenAlgorithm;
 import cn.org.codecrafters.simplejwt.exceptions.UnsupportedAlgorithmException;
@@ -27,23 +28,23 @@ import java.util.HashMap;
 import java.util.Map;
 
 /**
- * The JjwtTokenResolverConfig class provides the configuration for the
- * JjwtTokenResolverConfig.
+ * The {@code JjwtTokenResolverConfig} class provides the configuration for the
+ * {@link JjwtTokenResolver}.
  * <p>
  * This configuration class is used to establish the mapping between the
- * standard TokenAlgorithm defined within the JjwtTokenResolverConfig and
- * the specific algorithms used by the {@code io.jsonwebtoken:jjwt} library,
- * which is the underlying library used by JjwtTokenResolverConfig to handle
- * JSON Web Tokens (JWTs).
+ * standard {@link TokenAlgorithm} defined within the
+ * {@code JjwtTokenResolverConfig} and the specific algorithms used by the
+ * {@code io.jsonwebtoken:jjwt} library, which is the underlying library used
+ * by {@code JjwtTokenResolver} to handle JSON Web Tokens (JWTs).
  * <p>
  * <b>Algorithm Mapping:</b>
- * The JjwtTokenResolverConfig class allows specifying the relationship
- * between the standard TokenAlgorithm instances supported by
- * JjwtTokenResolverConfig and the corresponding algorithms used by the
+ * The {@code JjwtTokenResolverConfig} allows specifying the relationship
+ * between the standard {@link TokenAlgorithm} instances supported by {@link
+ * JjwtTokenResolver} and the corresponding algorithms used by the
  * {@code io.jsonwebtoken:jjwt} library. The mapping is achieved using a Map,
- * where the keys are the standard TokenAlgorithm instances, and the values
- * represent the algorithm functions used by {@code io.jsonwebtoken:jjwt}
- * library for each corresponding key.
+ * where the keys are the standard {@link TokenAlgorithm} instances, and the
+ * values represent the algorithm functions used by
+ * {@code io.jsonwebtoken:jjwt} library for each corresponding key.
  * <p>
  * <b>Note:</b>
  * The provided algorithm mapping should be consistent with the actual
@@ -78,24 +79,25 @@ public final class JjwtTokenResolverConfig implements TokenResolverConfig<Signat
 
     /**
      * Gets the algorithm function corresponding to the specified
-     * TokenAlgorithm.
+     * {@link TokenAlgorithm}.
      * <p>
      * This method returns the algorithm function associated with the given
-     * TokenAlgorithm. The provided TokenAlgorithm represents the specific
-     * algorithm for which the corresponding algorithm function is required.
-     * The returned AlgorithmFunction represents the function implementation
-     * that can be used by the TokenResolver to handle the specific algorithm.
+     * {@link TokenAlgorithm}. The provided {@link TokenAlgorithm} represents
+     * the specific algorithm for which the corresponding algorithm function is
+     * required. The returned algorithm function represents the function
+     * implementation that can be used by the {@link TokenResolver} to handle
+     * the specific algorithm.
      *
-     * @param algorithm the TokenAlgorithm for which the algorithm function is
-     *                  required
-     * @return the algorithm function associated with the given TokenAlgorithm
+     * @param algorithm the {@link TokenAlgorithm} for which the algorithm
+     *                  function is required
+     * @return the algorithm function associated with the given {@link
+     * TokenAlgorithm}
      */
     @Override
     public SignatureAlgorithm getAlgorithm(TokenAlgorithm algorithm) {
         if (!SUPPORTED_ALGORITHMS.containsKey(algorithm)) {
             throw new UnsupportedAlgorithmException("""
-                    The request algorithm is not supported by our system yet. Please change to supported ones.
-                    """);
+                    The request algorithm is not supported by our system yet. Please change to supported ones.""");
         }
         return SUPPORTED_ALGORITHMS.get(algorithm);
     }
diff --git a/simple-jwt-jjwt/src/main/java/cn/org/codecrafters/simplejwt/jjwt/package-info.java b/simple-jwt-jjwt/src/main/java/cn/org/codecrafters/simplejwt/jjwt/package-info.java
index 5a3eca5..1753d09 100644
--- a/simple-jwt-jjwt/src/main/java/cn/org/codecrafters/simplejwt/jjwt/package-info.java
+++ b/simple-jwt-jjwt/src/main/java/cn/org/codecrafters/simplejwt/jjwt/package-info.java
@@ -33,18 +33,20 @@
  * this class as the main token resolver in the Simple JWT project when
  * integrating {@code io.jsonwebtoken:jjwt-api} as the JWT management library.
  * <p>
- * The {@code JjwtTokenResolver} relies on the {@code io.jsonwebtoken:jjwt-api}
+ * The {@link cn.org.codecrafters.simplejwt.jjwt.JjwtTokenResolver} relies on
+ * the {@code io.jsonwebtoken:jjwt-api}
  * library to handle the underlying JWT operations, including token creation,
  * validation, and extraction. It utilizes the {@code io.jsonwebtoken:jjwt-api}
- * {@code Algorithm} class to define and use different algorithms for JWT
- * signing and verification.
+ * {@link io.jsonwebtoken.SignatureAlgorithm} class to define and use different
+ * algorithms for JWT signing and verification.
  * <p>
- * To use the {@code JjwtTokenResolver}, developers must provide the necessary
- * configurations and dependencies, such as the {@code GuidCreator} for
- * generating unique JWT IDs (JTI), the supported algorithm function, the
- * issuer name, and the secret key used for token signing and validation. The
- * {@code JjwtTokenResolverConfig} class provides a convenient way to configure
- * these dependencies.
+ * To use the {@link cn.org.codecrafters.simplejwt.jjwt.JjwtTokenResolver},
+ * developers must provide the necessary configurations and dependencies, such
+ * as the {@link cn.org.codecrafters.guid.GuidCreator} for generating unique
+ * JWT IDs (JTI), the supported algorithm function, the issuer name, and the
+ * secret key used for token signing and validation. The
+ * {@link cn.org.codecrafters.simplejwt.jjwt.config.JjwtTokenResolverConfig}
+ * class provides a convenient way to configure these dependencies.
  * <p>
  * Developers using the {@code io.jsonwebtoken:jjwt-api} integration should be
  * familiar with the concepts and usage of the {@code io.jsonwebtoken:jjwt-api}
diff --git a/simple-jwt-spring-boot-starter/src/main/java/cn/org/codecrafters/simplejwt/autoconfiguration/AuthzeroTokenResolverAutoConfiguration.java b/simple-jwt-spring-boot-starter/src/main/java/cn/org/codecrafters/simplejwt/autoconfiguration/AuthzeroTokenResolverAutoConfiguration.java
index a32a3e2..747b36a 100644
--- a/simple-jwt-spring-boot-starter/src/main/java/cn/org/codecrafters/simplejwt/autoconfiguration/AuthzeroTokenResolverAutoConfiguration.java
+++ b/simple-jwt-spring-boot-starter/src/main/java/cn/org/codecrafters/simplejwt/autoconfiguration/AuthzeroTokenResolverAutoConfiguration.java
@@ -34,20 +34,21 @@ import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.DependsOn;
 
 /**
- * SimpleJwtAutoConfiguration is responsible for automatically configuring the
- * Simple JWT library with {@code com.auth0:java-jwt} when used in a Spring
- * Boot application. It provides default settings and configurations to ensure
- * that the library works smoothly without requiring manual configuration.
+ * {@code AuthzeroTokenResolverAutoConfiguration} is responsible for
+ * automatically configuring the Simple JWT library with
+ * {@code com.auth0:java-jwt} when used in a Spring Boot application. It
+ * provides default settings and configurations to ensure that the library
+ * works smoothly without requiring manual configuration.
  * <p>
  * This autoconfiguration class sets up the necessary beans and components
  * required for JWT generation and validation. It automatically creates and
- * configures the {@link TokenResolver} bean based on the available options and
- * properties.
+ * configures the {@link AuthzeroTokenResolver} bean based on the available
+ * options and properties.
  * <p>
  * Developers using the Simple JWT library with Spring Boot do not need to
  * explicitly configure the library, as the autoconfiguration takes care of
  * setting up the necessary components and configurations automatically.
- * However, developers still have the flexibility to customize the behavior of
+ * However, developers still have the flexibility to customise the behavior of
  * the library by providing their own configurations and properties.
  *
  * @author Zihlu Wang
diff --git a/simple-jwt-spring-boot-starter/src/main/java/cn/org/codecrafters/simplejwt/autoconfiguration/GuidAutoConfiguration.java b/simple-jwt-spring-boot-starter/src/main/java/cn/org/codecrafters/simplejwt/autoconfiguration/GuidAutoConfiguration.java
index fbc9017..a4d452c 100644
--- a/simple-jwt-spring-boot-starter/src/main/java/cn/org/codecrafters/simplejwt/autoconfiguration/GuidAutoConfiguration.java
+++ b/simple-jwt-spring-boot-starter/src/main/java/cn/org/codecrafters/simplejwt/autoconfiguration/GuidAutoConfiguration.java
@@ -29,7 +29,7 @@ import org.springframework.context.annotation.Conditional;
 import java.util.UUID;
 
 /**
- * Autoconfiguration for injecting a {@code GuidCreator} for generating jwt id.
+ * Autoconfiguration for injecting a {@link GuidCreator} for generating jwt id.
  *
  * @author Zihlu Wang
  * @version 1.1.0
diff --git a/simple-jwt-spring-boot-starter/src/main/java/cn/org/codecrafters/simplejwt/autoconfiguration/JjwtTokenResolverAutoConfiguration.java b/simple-jwt-spring-boot-starter/src/main/java/cn/org/codecrafters/simplejwt/autoconfiguration/JjwtTokenResolverAutoConfiguration.java
index 452254a..26cfc87 100644
--- a/simple-jwt-spring-boot-starter/src/main/java/cn/org/codecrafters/simplejwt/autoconfiguration/JjwtTokenResolverAutoConfiguration.java
+++ b/simple-jwt-spring-boot-starter/src/main/java/cn/org/codecrafters/simplejwt/autoconfiguration/JjwtTokenResolverAutoConfiguration.java
@@ -34,7 +34,7 @@ import org.springframework.boot.context.properties.EnableConfigurationProperties
 import org.springframework.context.annotation.Bean;
 
 /**
- * JjwtTokenResolverAutoConfiguration is responsible for automatically
+ * {@code JjwtTokenResolverAutoConfiguration} is responsible for automatically
  * configuring the Simple JWT library with {@code io.jsonwebtoken:jjwt-api}
  * when used in a Spring Boot application. It provides default settings and
  * configurations to ensure that the library works smoothly without requiring
@@ -42,8 +42,8 @@ import org.springframework.context.annotation.Bean;
  * <p>
  * This autoconfiguration class sets up the necessary beans and components
  * required for JWT generation and validation. It automatically creates and
- * configures the {@link TokenResolver} bean based on the available options and
- * properties.
+ * configures the {@link JjwtTokenResolver} bean based on the available options
+ * and properties.
  * <p>
  * Developers using the Simple JWT library with Spring Boot do not need to
  * explicitly configure the library, as the autoconfiguration takes care of
diff --git a/simple-jwt-spring-boot-starter/src/main/java/cn/org/codecrafters/simplejwt/autoconfiguration/conditions/GuidCreatorCondition.java b/simple-jwt-spring-boot-starter/src/main/java/cn/org/codecrafters/simplejwt/autoconfiguration/conditions/GuidCreatorCondition.java
index 4c9ecf5..287b3cd 100644
--- a/simple-jwt-spring-boot-starter/src/main/java/cn/org/codecrafters/simplejwt/autoconfiguration/conditions/GuidCreatorCondition.java
+++ b/simple-jwt-spring-boot-starter/src/main/java/cn/org/codecrafters/simplejwt/autoconfiguration/conditions/GuidCreatorCondition.java
@@ -9,7 +9,7 @@ import org.springframework.core.type.AnnotatedTypeMetadata;
 import java.util.Objects;
 
 /**
- * The condition to create bean {@code jtiCreator}.
+ * The conditions to create bean {@code jtiCreator}.
  *
  * @author Zihlu Wang
  * @version 1.1.0
diff --git a/simple-jwt-spring-boot-starter/src/main/java/cn/org/codecrafters/simplejwt/autoconfiguration/properties/SimpleJwtProperties.java b/simple-jwt-spring-boot-starter/src/main/java/cn/org/codecrafters/simplejwt/autoconfiguration/properties/SimpleJwtProperties.java
index fab5669..8105cf3 100644
--- a/simple-jwt-spring-boot-starter/src/main/java/cn/org/codecrafters/simplejwt/autoconfiguration/properties/SimpleJwtProperties.java
+++ b/simple-jwt-spring-boot-starter/src/main/java/cn/org/codecrafters/simplejwt/autoconfiguration/properties/SimpleJwtProperties.java
@@ -25,20 +25,20 @@ import org.springframework.boot.context.properties.ConfigurationProperties;
 
 /**
  * {@code SimpleJwtProperties} is a configuration properties class used to
- * store the properties related to Simple JWT library configuration. These
+ * store the properties related to Simple JWT library configurations. These
  * properties can be configured in the application's properties file (e.g.,
  * application.properties) with the prefix "code-crafters.simple-jwt".
  * <p>
- * SimpleJwtProperties provides configuration options for the JWT algorithm,
- * issuer, and secret. The properties are used by the {@link
+ * {@code SimpleJwtProperties} provides configuration options for the JWT
+ * algorithm, issuer, and secret. The properties are used by the {@link
  * AuthzeroTokenResolverAutoConfiguration} and {@link
  * cn.org.codecrafters.simplejwt.jjwt.JjwtTokenResolver} to set up the
  * necessary configurations for JWT generation and validation.
  * <p>
- * Developers can customize the JWT algorithm, issuer, and secret by setting
+ * Developers can customise the JWT algorithm, issuer, and secret by setting
  * the corresponding properties in the application's properties file. The
- * SimpleJwtAutoConfiguration class reads these properties and uses them to
- * create the TokenResolver bean with the desired configuration.
+ * {@code SimpleJwtAutoConfiguration} class reads these properties and uses
+ * them to create the TokenResolver bean with the desired configuration.
  *
  * @author Zihlu Wang
  * @version 1.1.0
diff --git a/webcal/src/main/java/cn/org/codecrafters/webcal/WebCalendar.java b/webcal/src/main/java/cn/org/codecrafters/webcal/WebCalendar.java
index 9174a2b..e16b581 100644
--- a/webcal/src/main/java/cn/org/codecrafters/webcal/WebCalendar.java
+++ b/webcal/src/main/java/cn/org/codecrafters/webcal/WebCalendar.java
@@ -21,11 +21,12 @@ import java.util.ArrayList;
 import java.util.List;
 
 /**
- * The WebCalendar class represents a web calendar in iCalendar format.
+ * {@code WebCalendar} class represents a web calendar in iCalendar format.
  * <p>
- * It allows users to create and customize calendar components and events and
- * generate an iCalendar string containing all the calendar information.
- * <p>Usage Example:
+ * It allows users to create and customise calendar components and events and
+ * generate an <b>iCalendar</b> string containing all the calendar information.
+ * <p>
+ * Usage Example:
  * <pre>
  * WebCalendar calendar = new WebCalendar()
  *         .setName("My Web Calendar")
@@ -38,9 +39,9 @@ import java.util.List;
  * String iCalendarString = calendar.resolve();
  * </pre>
  * <p>
- * The WebCalendar class is designed to generate an iCalendar string conforming
- * to the iCalendar specification, which can be used to share calendar data
- * with other calendar applications or services.
+ * The {@code WebCalendar} class is designed to generate an iCalendar string
+ * conforming to the iCalendar specification, which can be used to share
+ * calendar data with other calendar applications or services.
  *
  * @author Zihlu Wang
  * @version 1.1.0
@@ -49,7 +50,7 @@ import java.util.List;
 public final class WebCalendar {
 
     /**
-     * The VCALENDAR tag for iCalendar format
+     * The {@code VCALENDAR} tag for iCalendar format
      */
     private final static String TAG = "VCALENDAR";
 
@@ -60,7 +61,6 @@ public final class WebCalendar {
 
     /**
      * The company who produces this calendar.
-     *
      * <p>
      * This property will be used in {@code PRODID}.
      */
@@ -68,7 +68,6 @@ public final class WebCalendar {
 
     /**
      * The product name.
-     *
      * <p>
      * This property will be used in {@code PRODID}
      */
diff --git a/webcal/src/main/java/cn/org/codecrafters/webcal/WebCalendarEvent.java b/webcal/src/main/java/cn/org/codecrafters/webcal/WebCalendarEvent.java
index 23ce851..c073d19 100644
--- a/webcal/src/main/java/cn/org/codecrafters/webcal/WebCalendarEvent.java
+++ b/webcal/src/main/java/cn/org/codecrafters/webcal/WebCalendarEvent.java
@@ -28,17 +28,16 @@ import java.util.Optional;
 import java.util.UUID;
 
 /**
- * The WebCalendarEvent class represents an event in the web calendar. It
- * extends the abstract class WebCalendarNode and provides additional methods
- * to set properties specific to events.
- *
+ * The {@code WebCalendarEvent} class represents an event in the web calendar.
+ * It extends the abstract class WebCalendarNode and provides additional
+ * methods to set properties specific to events.
  * <p>
  * Users can use the methods in this class to add categories, set the
- * classification, add comments, descriptions, locations, set percent complete
- * , set priority, set summary, set start time, set end time, set duration, set
- * URL, set UID, and set timezone for the event. After setting the properties,
- * users can call the {@link #resolve()} method to generate the corresponding
- * iCalendar content for the event.
+ * classification, add comments, descriptions, locations, set percent
+ * complete, set priority, set summary, set start time, set end time, set
+ * duration, set URL, set UID, and set timezone for the event. After setting
+ * the properties, users can call the {@link #resolve()} method to generate the
+ * corresponding iCalendar content for the event.
  *
  * @author Zihlu Wang
  * @version 1.1.0
@@ -275,7 +274,7 @@ public final class WebCalendarEvent extends WebCalendarNode {
                         .map((item) -> "DTEND" + Optional.ofNullable(timezone).map(tz -> ";TZID=" + tz).orElse("") + ":" +
                                 end.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME) + "\n").orElse("") +
                 Optional.ofNullable(classification)
-                        .map((item) -> "CLASS:" + item.getClassification() + "\n").orElse("") +
+                        .map((item) -> "CLASS:" + item.name() + "\n").orElse("") +
                 Optional.ofNullable(comment).map((item) -> "COMMENT:" + item + "\n").orElse("") +
                 Optional.ofNullable(description).map((item) -> "DESCRIPTION:" + item + "\n").orElse("") +
                 Optional.ofNullable(location).map((item) -> "LOCATION:" + item + "\n").orElse("") +
diff --git a/webcal/src/main/java/cn/org/codecrafters/webcal/WebCalendarNode.java b/webcal/src/main/java/cn/org/codecrafters/webcal/WebCalendarNode.java
index ed85ab0..5f56b11 100644
--- a/webcal/src/main/java/cn/org/codecrafters/webcal/WebCalendarNode.java
+++ b/webcal/src/main/java/cn/org/codecrafters/webcal/WebCalendarNode.java
@@ -25,14 +25,13 @@ import java.util.ArrayList;
 import java.util.List;
 
 /**
- * The abstract sealed class WebCalendarNode represents a node in the web
- * calendar, such as an event, a to-do item, or an alarm. It provides common
- * properties and methods for all calendar components and events.
- *
+ * The abstract sealed class {@code WebCalendarNode} represents a node in the
+ * web calendar, such as an event, a to-do item, or an alarm. It provides
+ * common properties and methods for all calendar components and events.
  * <p>
- * Subclasses of WebCalendarNode should implement the {@link #resolve()} method
- * to generate the corresponding iCalendar content for the specific calendar
- * component or event.
+ * Subclasses of {@code WebCalendarNode} should implement the {@link
+ * #resolve()} method to generate the corresponding iCalendar content for the
+ * specific calendar component or event.
  *
  * @author Zihlu Wang
  * @version 1.1.0
diff --git a/webcal/src/main/java/cn/org/codecrafters/webcal/config/Classification.java b/webcal/src/main/java/cn/org/codecrafters/webcal/config/Classification.java
index 79a8ff1..2f40751 100644
--- a/webcal/src/main/java/cn/org/codecrafters/webcal/config/Classification.java
+++ b/webcal/src/main/java/cn/org/codecrafters/webcal/config/Classification.java
@@ -20,8 +20,8 @@ package cn.org.codecrafters.webcal.config;
 import lombok.Getter;
 
 /**
- * The Classification enum represents the classification levels of calendar
- * content based on RFC 5545.
+ * The {@code Classification} enum represents the classification levels of
+ * calendar content based on <b>RFC-5545</b>.
  * <p>
  * Calendar events or components can be classified as one of the following
  * levels:
@@ -44,7 +44,6 @@ import lombok.Getter;
  * @version 1.1.0
  * @since 1.0.0
  */
-@Getter
 public enum Classification {
 
     /**
@@ -53,7 +52,7 @@ public enum Classification {
      * Indicates that the calendar content is public and can be freely
      * distributed.
      */
-    PUBLIC("PUBLIC"),
+    PUBLIC,
 
     /**
      * Private classification level.
@@ -61,7 +60,7 @@ public enum Classification {
      * Indicates that the calendar content is private and should not be shared
      * with others.
      */
-    PRIVATE("PRIVATE"),
+    PRIVATE,
 
     /**
      * Confidential classification level.
@@ -69,22 +68,7 @@ public enum Classification {
      * Indicates that the calendar content is confidential and should be kept
      * strictly private.
      */
-    CONFIDENTIAL("CONFIDENTIAL"),
+    CONFIDENTIAL,
     ;
 
-    /**
-     * -- GETTER --
-     * Get the string representation of the classification level.
-     */
-    private final String classification;
-
-    /**
-     * Constructor for Classification enum.
-     *
-     * @param classification the classification level as a string representation
-     */
-    Classification(String classification) {
-        this.classification = classification;
-    }
-
 }
diff --git a/webcal/src/main/java/cn/org/codecrafters/webcal/config/package-info.java b/webcal/src/main/java/cn/org/codecrafters/webcal/config/package-info.java
index f0cf59d..fdfc842 100644
--- a/webcal/src/main/java/cn/org/codecrafters/webcal/config/package-info.java
+++ b/webcal/src/main/java/cn/org/codecrafters/webcal/config/package-info.java
@@ -16,10 +16,10 @@
  */
 
 /**
- * The package cn.org.codecrafters.webcal.config contains classes related to
- * the configuration and settings of the web calendar module. It provides
- * various configurations and constants used in the generation and resolution
- * of iCalendar content.
+ * The package {@code cn.org.codecrafters.webcal.config} contains classes
+ * related to the configuration and settings of the web calendar module. It
+ * provides various configurations and constants used in the generation and
+ * resolution of iCalendar content.
  * <p>The classes in this package include:</p>
  * <ul>
  *     <li>