AssertTools 删除 checkArgumentNotNull 方法，新增 checkExists、checkAffectedRows、checkAffectedOneRow 方法。

src/main/java/xyz/zhouxy/plusone/commons/model/ValidatableStringRecord.java

@@ -50,8 +50,8 @@ public abstract class ValidatableStringRecord
 
     protected ValidatableStringRecord(@Nonnull String value, @Nonnull Pattern pattern,
             @Nonnull String errorMessage) {
-        AssertTools.checkArgumentNotNull(value, "The value cannot be null.");
+        AssertTools.checkArgument(Objects.nonNull(value), "The value cannot be null.");
-        AssertTools.checkArgumentNotNull(pattern, "The pattern cannot be null.");
+        AssertTools.checkArgument(Objects.nonNull(pattern), "The pattern cannot be null.");
         this.matcher = pattern.matcher(value);
         AssertTools.checkArgument(this.matcher.matches(), errorMessage);
         this.value = value;

src/main/java/xyz/zhouxy/plusone/commons/util/ArrayTools.java

@@ -437,7 +437,7 @@ public class ArrayTools {
     }
 
     public static char[] repeat(char[] arr, int times, int maxLength) {
-        AssertTools.checkArgumentNotNull(arr);
+        AssertTools.checkArgument(Objects.nonNull(arr));
         AssertTools.checkArgument(times >= 0,
                 "The number of times must be greater than or equal to zero");
         AssertTools.checkArgument(maxLength >= 0,
@@ -458,7 +458,7 @@ public class ArrayTools {
     }
 
     public static byte[] repeat(byte[] arr, int times, int maxLength) {
-        AssertTools.checkArgumentNotNull(arr);
+        AssertTools.checkArgument(Objects.nonNull(arr));
         AssertTools.checkArgument(times >= 0,
                 "The number of times must be greater than or equal to zero");
         AssertTools.checkArgument(maxLength >= 0,
@@ -479,7 +479,7 @@ public class ArrayTools {
     }
 
     public static short[] repeat(short[] arr, int times, int maxLength) {
-        AssertTools.checkArgumentNotNull(arr);
+        AssertTools.checkArgument(Objects.nonNull(arr));
         AssertTools.checkArgument(times >= 0,
                 "The number of times must be greater than or equal to zero");
         AssertTools.checkArgument(maxLength >= 0,
@@ -500,7 +500,7 @@ public class ArrayTools {
     }
 
     public static int[] repeat(int[] arr, int times, int maxLength) {
-        AssertTools.checkArgumentNotNull(arr);
+        AssertTools.checkArgument(Objects.nonNull(arr));
         AssertTools.checkArgument(times >= 0,
                 "The number of times must be greater than or equal to zero");
         AssertTools.checkArgument(maxLength >= 0,
@@ -521,7 +521,7 @@ public class ArrayTools {
     }
 
     public static long[] repeat(long[] arr, int times, int maxLength) {
-        AssertTools.checkArgumentNotNull(arr);
+        AssertTools.checkArgument(Objects.nonNull(arr));
         AssertTools.checkArgument(times >= 0,
                 "The number of times must be greater than or equal to zero");
         AssertTools.checkArgument(maxLength >= 0,
@@ -542,7 +542,7 @@ public class ArrayTools {
     }
 
     public static float[] repeat(float[] arr, int times, int maxLength) {
-        AssertTools.checkArgumentNotNull(arr);
+        AssertTools.checkArgument(Objects.nonNull(arr));
         AssertTools.checkArgument(times >= 0,
                 "The number of times must be greater than or equal to zero");
         AssertTools.checkArgument(maxLength >= 0,
@@ -563,7 +563,7 @@ public class ArrayTools {
     }
 
     public static double[] repeat(double[] arr, int times, int maxLength) {
-        AssertTools.checkArgumentNotNull(arr);
+        AssertTools.checkArgument(Objects.nonNull(arr));
         AssertTools.checkArgument(times >= 0,
                 "The number of times must be greater than or equal to zero");
         AssertTools.checkArgument(maxLength >= 0,
@@ -592,7 +592,7 @@ public class ArrayTools {
     }
 
     public static void fill(char[] a, int fromIndex, int toIndex, char... values) {
-        AssertTools.checkArgumentNotNull(a);
+        AssertTools.checkArgument(Objects.nonNull(a));
         if (values.length == 0) {
             return;
         }
@@ -621,7 +621,7 @@ public class ArrayTools {
     }
 
     public static void fill(byte[] a, int fromIndex, int toIndex, byte... values) {
-        AssertTools.checkArgumentNotNull(a);
+        AssertTools.checkArgument(Objects.nonNull(a));
         if (values.length == 0) {
             return;
         }
@@ -650,7 +650,7 @@ public class ArrayTools {
     }
 
     public static void fill(short[] a, int fromIndex, int toIndex, short... values) {
-        AssertTools.checkArgumentNotNull(a);
+        AssertTools.checkArgument(Objects.nonNull(a));
         if (values.length == 0) {
             return;
         }
@@ -679,7 +679,7 @@ public class ArrayTools {
     }
 
     public static void fill(int[] a, int fromIndex, int toIndex, int... values) {
-        AssertTools.checkArgumentNotNull(a);
+        AssertTools.checkArgument(Objects.nonNull(a));
         if (values.length == 0) {
             return;
         }
@@ -708,7 +708,7 @@ public class ArrayTools {
     }
 
     public static void fill(long[] a, int fromIndex, int toIndex, long... values) {
-        AssertTools.checkArgumentNotNull(a);
+        AssertTools.checkArgument(Objects.nonNull(a));
         if (values.length == 0) {
             return;
         }
@@ -737,7 +737,7 @@ public class ArrayTools {
     }
 
     public static void fill(float[] a, int fromIndex, int toIndex, float... values) {
-        AssertTools.checkArgumentNotNull(a);
+        AssertTools.checkArgument(Objects.nonNull(a));
         if (values.length == 0) {
             return;
         }
@@ -766,7 +766,7 @@ public class ArrayTools {
     }
 
     public static void fill(double[] a, int fromIndex, int toIndex, double... values) {
-        AssertTools.checkArgumentNotNull(a);
+        AssertTools.checkArgument(Objects.nonNull(a));
         if (values.length == 0) {
             return;
         }
@@ -799,7 +799,7 @@ public class ArrayTools {
     }
 
     private static <T> void fillInternal(@Nonnull T[] a, int fromIndex, int toIndex, @Nullable T[] values) {
-        AssertTools.checkArgumentNotNull(a);
+        AssertTools.checkArgument(Objects.nonNull(a));
         if (values == null || values.length == 0) {
             return;
         }

src/main/java/xyz/zhouxy/plusone/commons/util/AssertTools.java

@@ -16,10 +16,15 @@
 
 package xyz.zhouxy.plusone.commons.util;
 
+import java.util.Objects;
+import java.util.Optional;
 import java.util.function.Supplier;
 
 import javax.annotation.Nonnull;
 
+import xyz.zhouxy.plusone.commons.exception.DataNotExistsException;
+import xyz.zhouxy.plusone.commons.exception.system.DataOperationResultException;
+
 /**
  * 断言工具
  *
@@ -30,91 +35,231 @@ import javax.annotation.Nonnull;
  * <pre>
  * AssertTools.checkArgument(StringUtils.hasText(str), "The argument cannot be blank.");
  * AssertTools.checkState(ArrayUtils.isNotEmpty(result), "The result cannot be empty.");
- * AssertTools.checkCondition(!CollectionUtils.isEmpty(roles), () -> new InvalidInputException("The roles cannot be empty."));
+ * AssertTools.checkCondition(!CollectionUtils.isEmpty(roles),
- * AssertTools.checkCondition(RegexTools.matches(email, PatternConsts.EMAIL), "must be a well-formed email address");
+ *     () -> new InvalidInputException("The roles cannot be empty."));
+ * AssertTools.checkCondition(RegexTools.matches(email, PatternConsts.EMAIL),
+ *     "must be a well-formed email address");
  * </pre>
  *
  * @author <a href="http://zhouxy.xyz:3000/ZhouXY108">ZhouXY</a>
  */
 public class AssertTools {
 
-    // #region - checkArgument
+    // ================================
-
+    // #region - Argument
-    public static <T> void checkArgumentNotNull(T argument) {
+    // ================================
-        checkCondition(argument != null, () -> new IllegalArgumentException("The argument cannot be null."));
-    }
-
-    public static <T> void checkArgumentNotNull(T argument, String errMsg) {
-        checkCondition(argument != null, () -> new IllegalArgumentException(errMsg));
-    }
-
-    public static <T> void checkArgumentNotNull(T argument, Supplier<String> messageSupplier) {
-        checkCondition(argument != null, () -> new IllegalArgumentException(messageSupplier.get()));
-    }
-
-    public static <T> void checkArgumentNotNull(T argument, String format, Object... args) {
-        checkCondition(argument != null, () -> new IllegalArgumentException(String.format(format, args)));
-    }
 
+    /** Throw {@link IllegalArgumentException} if the {@code condition} is false. */
     public static void checkArgument(boolean condition) {
         checkCondition(condition, IllegalArgumentException::new);
     }
 
+    /** Throw {@link IllegalArgumentException} if the {@code condition} is false. */
     public static void checkArgument(boolean condition, String errMsg) {
         checkCondition(condition, () -> new IllegalArgumentException(errMsg));
     }
 
-    public static void checkArgument(boolean condition, Supplier<String> messageSupplier) {
+    /** Throw {@link IllegalArgumentException} if the {@code condition} is false. */
+    public static void checkArgument(boolean condition, @Nonnull Supplier<String> messageSupplier) {
         checkCondition(condition, () -> new IllegalArgumentException(messageSupplier.get()));
     }
 
+    /** Throw {@link IllegalArgumentException} if the {@code condition} is false. */
     public static void checkArgument(boolean condition, String format, Object... args) {
         checkCondition(condition, () -> new IllegalArgumentException(String.format(format, args)));
     }
 
-    // #endregion
+    // ================================
+    // #endregion - Argument
+    // ================================
 
-    // #region - checkState
+    // ================================
+    // #region - State
+    // ================================
 
+    /** Throw {@link IllegalStateException} if the {@code condition} is false. */
     public static void checkState(boolean condition) {
         checkCondition(condition, IllegalStateException::new);
     }
 
+    /** Throw {@link IllegalStateException} if the {@code condition} is false. */
     public static void checkState(boolean condition, String errMsg) {
         checkCondition(condition, () -> new IllegalStateException(errMsg));
     }
 
-    public static void checkState(boolean condition, Supplier<String> messageSupplier) {
+    /** Throw {@link IllegalStateException} if the {@code condition} is false. */
+    public static void checkState(boolean condition, @Nonnull Supplier<String> messageSupplier) {
         checkCondition(condition, () -> new IllegalStateException(messageSupplier.get()));
     }
 
+    /** Throw {@link IllegalStateException} if the {@code condition} is false. */
     public static void checkState(boolean condition, String format, Object... args) {
         checkCondition(condition, () -> new IllegalStateException(String.format(format, args)));
     }
 
+    // ================================
     // #endregion
+    // ================================
 
-    // #region - checkNotNull
+    // ================================
+    // #region - NotNull
+    // ================================
 
+    /** Throw {@link NullPointerException} if the {@code obj} is null. */
     public static <T> void checkNotNull(T obj) {
         checkCondition(obj != null, NullPointerException::new);
     }
 
+    /** Throw {@link NullPointerException} if the {@code obj} is null. */
     public static <T> void checkNotNull(T obj, String errMsg) {
         checkCondition(obj != null, () -> new NullPointerException(errMsg));
     }
 
-    public static <T> void checkNotNull(T obj, Supplier<String> messageSupplier) {
+    /** Throw {@link NullPointerException} if the {@code obj} is null. */
+    public static <T> void checkNotNull(T obj, @Nonnull Supplier<String> messageSupplier) {
         checkCondition(obj != null, () -> new NullPointerException(messageSupplier.get()));
     }
 
+    /** Throw {@link NullPointerException} if the {@code obj} is null. */
     public static <T> void checkNotNull(T obj, String format, Object... args) {
         checkCondition(obj != null, () -> new NullPointerException(String.format(format, args)));
     }
 
+    // ================================
     // #endregion
+    // ================================
 
-    // #region - checkCondition
+    // ================================
+    // #region - Exists
+    // ================================
+
+    /** Throw {@link DataNotExistsException} if the {@code obj} is null. */
+    public static <T> T checkExists(T obj)
+            throws DataNotExistsException {
+        checkCondition(Objects.nonNull(obj), DataNotExistsException::new);
+        return obj;
+    }
+
+    /** Throw {@link DataNotExistsException} if the {@code obj} is null. */
+    public static <T> T checkExists(T obj, String message)
+            throws DataNotExistsException {
+        checkCondition(Objects.nonNull(obj), () -> new DataNotExistsException(message));
+        return obj;
+    }
+
+    /** Throw {@link DataNotExistsException} if the {@code obj} is null. */
+    public static <T> T checkExists(T obj, @Nonnull Supplier<String> messageSupplier)
+            throws DataNotExistsException {
+        checkCondition(Objects.nonNull(obj), () -> new DataNotExistsException(messageSupplier.get()));
+        return obj;
+    }
+
+    /** Throw {@link DataNotExistsException} if the {@code obj} is null. */
+    public static <T> T checkExists(T obj, String format, Object... args)
+            throws DataNotExistsException {
+        checkCondition(Objects.nonNull(obj), () -> new DataNotExistsException(String.format(format, args)));
+        return obj;
+    }
+
+    /** Throw {@link DataNotExistsException} if the {@code optional} is present. */
+    public static <T> T checkExists(@Nonnull Optional<T> optional)
+            throws DataNotExistsException {
+        checkCondition(optional.isPresent(), DataNotExistsException::new);
+        return optional.get();
+    }
+
+    /** Throw {@link DataNotExistsException} if the {@code optional} is present. */
+    public static <T> T checkExists(@Nonnull Optional<T> optional, String message)
+            throws DataNotExistsException {
+        checkCondition(optional.isPresent(), () -> new DataNotExistsException(message));
+        return optional.get();
+    }
+
+    /** Throw {@link DataNotExistsException} if the {@code optional} is present. */
+    public static <T> T checkExists(@Nonnull Optional<T> optional, @Nonnull Supplier<String> messageSupplier)
+            throws DataNotExistsException {
+        checkCondition(optional.isPresent(), () -> new DataNotExistsException(messageSupplier.get()));
+        return optional.get();
+    }
+
+    /** Throw {@link DataNotExistsException} if the {@code optional} is present. */
+    public static <T> T checkExists(@Nonnull Optional<T> optional, String format, Object... args)
+            throws DataNotExistsException {
+        checkCondition(optional.isPresent(), () -> new DataNotExistsException(String.format(format, args)));
+        return optional.get();
+    }
+
+    // ================================
+    // #endregion - Exists
+    // ================================
+
+    // ================================
+    // #region - AffectedRows
+    // ================================
+
+    public static void checkAffectedRows(int expectedValue, int result) {
+        checkAffectedRows(expectedValue, result,
+                "The number of rows affected is expected to be %d, but is: %d", expectedValue, result);
+    }
+
+    public static void checkAffectedRows(int expectedValue, int result, String message) {
+        checkCondition(expectedValue == result, () -> new DataOperationResultException(message));
+    }
+
+    public static void checkAffectedRows(int expectedValue, int result,
+            @Nonnull Supplier<String> messageSupplier) {
+        checkCondition(expectedValue == result,
+                () -> new DataOperationResultException(messageSupplier.get()));
+    }
+
+    public static void checkAffectedRows(int expectedValue, int result, String format, Object... args) {
+        checkCondition(expectedValue == result,
+                () -> new DataOperationResultException(String.format(format, args)));
+    }
+
+    public static void checkAffectedRows(long result, long expectedValue) {
+        checkCondition(expectedValue == result, DataOperationResultException::new);
+    }
+
+    public static void checkAffectedRows(long result, long expectedValue, String message) {
+        checkCondition(expectedValue == result, () -> new DataOperationResultException(message));
+    }
+
+    public static void checkAffectedRows(long result, long expectedValue,
+            @Nonnull Supplier<String> messageSupplier) {
+        checkCondition(expectedValue == result,
+                () -> new DataOperationResultException(messageSupplier.get()));
+    }
+
+    public static void checkAffectedRows(long result, long expectedValue, String format, Object... args) {
+        checkCondition(expectedValue == result,
+                () -> new DataOperationResultException(String.format(format, args)));
+    }
+
+    public static void checkAffectedOneRow(int result) {
+        checkAffectedRows(1, result,
+                () -> "The number of rows affected is expected to be 1, but is: " + result);
+    }
+
+    public static void checkAffectedOneRow(int result, String message) {
+        checkAffectedRows(1, result, message);
+    }
+
+    public static void checkAffectedOneRow(int result, @Nonnull Supplier<String> messageSupplier) {
+        checkAffectedRows(1, result, messageSupplier);
+    }
+
+    public static void checkAffectedOneRow(int result, String format, Object... args) {
+        checkAffectedRows(1, result, format, args);
+    }
+
+    // ================================
+    // #endregion - AffectedRows
+    // ================================
+
+    // ================================
+    // #region - Condition
+    // ================================
 
     public static <T extends Exception> void checkCondition(boolean condition, @Nonnull Supplier<T> e)
             throws T {
@@ -123,13 +268,19 @@ public class AssertTools {
         }
     }
 
+    // ================================
     // #endregion
+    // ================================
 
-    // #region - private constructor
+    // ================================
+    // #region - constructor
+    // ================================
 
     private AssertTools() {
         throw new IllegalStateException("Utility class");
     }
 
+    // ================================
     // #endregion
+    // ================================
 }

src/main/java/xyz/zhouxy/plusone/commons/util/IdGenerator.java

@@ -17,6 +17,7 @@
 package xyz.zhouxy.plusone.commons.util;
 
 import java.util.Map;
+import java.util.Objects;
 import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
 
@@ -40,7 +41,7 @@ public class IdGenerator {
     }
 
     public static String toSimpleString(UUID uuid) {
-        AssertTools.checkArgumentNotNull(uuid);
+        AssertTools.checkArgument(Objects.nonNull(uuid));
         return (uuidDigits(uuid.getMostSignificantBits() >> 32, 8) +
                 uuidDigits(uuid.getMostSignificantBits() >> 16, 4) +
                 uuidDigits(uuid.getMostSignificantBits(), 4) +

src/main/java/xyz/zhouxy/plusone/commons/util/RandomTools.java

@@ -17,6 +17,7 @@
 package xyz.zhouxy.plusone.commons.util;
 
 import java.security.SecureRandom;
+import java.util.Objects;
 import java.util.Random;
 import java.util.concurrent.ThreadLocalRandom;
 
@@ -41,20 +42,20 @@ public final class RandomTools {
      * @return 随机字符串
      */
     public static String randomStr(@Nonnull Random random, @Nonnull char[] sourceCharacters, int length) {
-        AssertTools.checkArgumentNotNull(random, "Random cannot be null.");
+        AssertTools.checkArgument(Objects.nonNull(random), "Random cannot be null.");
-        AssertTools.checkArgumentNotNull(sourceCharacters, "Source characters cannot be null.");
+        AssertTools.checkArgument(Objects.nonNull(sourceCharacters), "Source characters cannot be null.");
         AssertTools.checkArgument(length >= 0, "The length should be greater than or equal to zero.");
         return randomStrInternal(random, sourceCharacters, length);
     }
 
     public static String randomStr(@Nonnull char[] sourceCharacters, int length) {
-        AssertTools.checkArgumentNotNull(sourceCharacters, "Source characters cannot be null.");
+        AssertTools.checkArgument(Objects.nonNull(sourceCharacters), "Source characters cannot be null.");
         AssertTools.checkArgument(length >= 0, "The length should be greater than or equal to zero.");
         return randomStrInternal(ThreadLocalRandom.current(), sourceCharacters, length);
     }
 
     public static String secureRandomStr(@Nonnull char[] sourceCharacters, int length) {
-        AssertTools.checkArgumentNotNull(sourceCharacters, "Source characters cannot be null.");
+        AssertTools.checkArgument(Objects.nonNull(sourceCharacters), "Source characters cannot be null.");
         AssertTools.checkArgument(length >= 0, "The length should be greater than or equal to zero.");
         return randomStrInternal(DEFAULT_SECURE_RANDOM, sourceCharacters, length);
     }
@@ -70,20 +71,20 @@ public final class RandomTools {
      * @return 随机字符串
      */
     public static String randomStr(@Nonnull Random random, @Nonnull String sourceCharacters, int length) {
-        AssertTools.checkArgumentNotNull(random, "Random cannot be null.");
+        AssertTools.checkArgument(Objects.nonNull(random), "Random cannot be null.");
-        AssertTools.checkArgumentNotNull(sourceCharacters, "Source characters cannot be null.");
+        AssertTools.checkArgument(Objects.nonNull(sourceCharacters), "Source characters cannot be null.");
         AssertTools.checkArgument(length >= 0, "The length should be greater than or equal to zero.");
         return randomStrInternal(random, sourceCharacters, length);
     }
 
     public static String randomStr(@Nonnull String sourceCharacters, int length) {
-        AssertTools.checkArgumentNotNull(sourceCharacters, "Source characters cannot be null.");
+        AssertTools.checkArgument(Objects.nonNull(sourceCharacters), "Source characters cannot be null.");
         AssertTools.checkArgument(length >= 0, "The length should be greater than or equal to zero.");
         return randomStrInternal(ThreadLocalRandom.current(), sourceCharacters, length);
     }
 
     public static String secureRandomStr(@Nonnull String sourceCharacters, int length) {
-        AssertTools.checkArgumentNotNull(sourceCharacters, "Source characters cannot be null.");
+        AssertTools.checkArgument(Objects.nonNull(sourceCharacters), "Source characters cannot be null.");
         AssertTools.checkArgument(length >= 0, "The length should be greater than or equal to zero.");
         return randomStrInternal(DEFAULT_SECURE_RANDOM, sourceCharacters, length);
     }

src/main/java/xyz/zhouxy/plusone/commons/util/StringTools.java

@@ -16,6 +16,8 @@
 
 package xyz.zhouxy.plusone.commons.util;
 
+import java.util.Objects;
+
 import com.google.common.annotations.Beta;
 
 @Beta
@@ -40,7 +42,7 @@ public class StringTools {
     }
 
     public static String repeat(String str, int times, int maxLength) {
-        AssertTools.checkArgumentNotNull(str);
+        AssertTools.checkArgument(Objects.nonNull(str));
         return String.valueOf(ArrayTools.repeat(str.toCharArray(), times, maxLength));
     }