From 1b2234f6a22a5fe042f5baba3740ff79ed936b24 Mon Sep 17 00:00:00 2001
From: TomXin <766781886@qq.com>
Date: Fri, 18 Feb 2022 18:18:42 +0800
Subject: [PATCH] =?UTF-8?q?=E6=89=A9=E5=B1=95CheckedUtil=E7=9A=84uncheck?=
 =?UTF-8?q?=E6=96=B9=E6=B3=95,=E4=BD=BF=E5=85=B6=E6=94=AF=E6=8C=81?=
 =?UTF-8?q?=E8=87=AA=E5=AE=9A=E4=B9=89=E5=BC=82=E5=B8=B8=E8=BD=AC=E6=8D=A2?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../hutool/core/exceptions/CheckedUtil.java   | 155 +++++++++++++++++-
 1 file changed, 152 insertions(+), 3 deletions(-)

diff --git a/hutool-core/src/main/java/cn/hutool/core/exceptions/CheckedUtil.java b/hutool-core/src/main/java/cn/hutool/core/exceptions/CheckedUtil.java
index f1380a2d0..3b76d8a78 100644
--- a/hutool-core/src/main/java/cn/hutool/core/exceptions/CheckedUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/exceptions/CheckedUtil.java
@@ -145,6 +145,31 @@ public class CheckedUtil {
 		};
 	}
 
+	/**
+	 * 接收一个可以转化成 cn.hutool.core.lang.func.Func的Lambda表达式，和一个可以把Exception转化成RuntimeExceptionde的表达式，当执行表达式抛出任何异常的时候，都会转化成运行时异常
+	 * 如此一来，代码中就不用显示的try-catch转化成运行时异常
+	 *
+	 * @param expression  Lambda表达式
+	 * @param rteSupplier 转化运行时异常的表达式
+	 * @param <P>         运行时传入的参数类型
+	 * @param <R>         最终返回的数据类型
+	 * @return {@link FuncRt}
+	 */
+	public static <P, R> FuncRt<P, R> uncheck(Func<P, R> expression, Supplier1<RuntimeException, Exception> rteSupplier) {
+		Objects.requireNonNull(expression, "expression can not be null");
+		return t -> {
+			try {
+				return expression.call(t);
+			} catch (Exception e) {
+				if (rteSupplier == null) {
+					throw new RuntimeException(e);
+				} else {
+					throw rteSupplier.get(e);
+				}
+			}
+		};
+	}
+
 	/**
 	 * 接收一个可以转化成 cn.hutool.core.lang.func.Func0的Lambda表达式，和一个RuntimeException，当执行表达式抛出任何异常的时候，都会转化成运行时异常
 	 * 如此一来，代码中就不用显示的try-catch转化成运行时异常
@@ -170,6 +195,30 @@ public class CheckedUtil {
 		};
 	}
 
+	/**
+	 * 接收一个可以转化成 cn.hutool.core.lang.func.Func0的Lambda表达式，和一个可以把Exception转化成RuntimeExceptionde的表达式，当执行表达式抛出任何异常的时候，都会转化成运行时异常
+	 * 如此一来，代码中就不用显示的try-catch转化成运行时异常
+	 *
+	 * @param expression  Lambda表达式
+	 * @param rteSupplier 转化运行时异常的表达式
+	 * @param <R>         最终返回的数据类型
+	 * @return {@link Func0Rt}
+	 */
+	public static <R> Func0Rt<R> uncheck(Func0<R> expression, Supplier1<RuntimeException, Exception> rteSupplier) {
+		Objects.requireNonNull(expression, "expression can not be null");
+		return () -> {
+			try {
+				return expression.call();
+			} catch (Exception e) {
+				if (rteSupplier == null) {
+					throw new RuntimeException(e);
+				} else {
+					throw rteSupplier.get(e);
+				}
+			}
+		};
+	}
+
 	/**
 	 * 接收一个可以转化成 cn.hutool.core.lang.func.Func1的Lambda表达式，和一个RuntimeException，当执行表达式抛出任何异常的时候，都会转化成运行时异常
 	 * 如此一来，代码中就不用显示的try-catch转化成运行时异常
@@ -197,7 +246,32 @@ public class CheckedUtil {
 	}
 
 	/**
-	 * 接收一个可以转化成 cn.hutool.core.lang.func.VoidFunc的Lambda表达式，和一个RuntimeException，当执行表达式抛出任何异常的时候，都会转化成运行时异常
+	 * 接收一个可以转化成 cn.hutool.core.lang.func.Func1的Lambda表达式，和一个可以把Exception转化成RuntimeExceptionde的表达式，当执行表达式抛出任何异常的时候，都会转化成运行时异常
+	 * 如此一来，代码中就不用显示的try-catch转化成运行时异常
+	 *
+	 * @param expression  Lambda表达式
+	 * @param rteSupplier 转化运行时异常的表达式
+	 * @param <P>         运行时传入的参数类型
+	 * @param <R>         最终返回的数据类型
+	 * @return {@link Func1Rt}
+	 */
+	public static <P, R> Func1Rt<P, R> uncheck(Func1<P, R> expression, Supplier1<RuntimeException, Exception> rteSupplier) {
+		Objects.requireNonNull(expression, "expression can not be null");
+		return t -> {
+			try {
+				return expression.call(t);
+			} catch (Exception e) {
+				if (rteSupplier == null) {
+					throw new RuntimeException(e);
+				} else {
+					throw rteSupplier.get(e);
+				}
+			}
+		};
+	}
+
+	/**
+	 * 接收一个可以转化成 cn.hutool.core.lang.func.VoidFunc的Lambda表达式，和一个可以把Exception转化成RuntimeExceptionde的表达式，当执行表达式抛出任何异常的时候，都会转化成运行时异常
 	 * 如此一来，代码中就不用显示的try-catch转化成运行时异常
 	 *
 	 * @param expression Lambda表达式
@@ -221,6 +295,30 @@ public class CheckedUtil {
 		};
 	}
 
+	/**
+	 * 接收一个可以转化成 cn.hutool.core.lang.func.VoidFunc的Lambda表达式，和一个可以把Exception转化成RuntimeExceptionde的表达式，当执行表达式抛出任何异常的时候，都会转化成运行时异常
+	 * 如此一来，代码中就不用显示的try-catch转化成运行时异常
+	 *
+	 * @param expression  Lambda表达式
+	 * @param rteSupplier 转化运行时异常的表达式
+	 * @param <P>         运行时传入的参数类型
+	 * @return {@link VoidFuncRt}
+	 */
+	public static <P> VoidFuncRt<P> uncheck(VoidFunc<P> expression, Supplier1<RuntimeException, Exception> rteSupplier) {
+		Objects.requireNonNull(expression, "expression can not be null");
+		return t -> {
+			try {
+				expression.call(t);
+			} catch (Exception e) {
+				if (rteSupplier == null) {
+					throw new RuntimeException(e);
+				} else {
+					throw rteSupplier.get(e);
+				}
+			}
+		};
+	}
+
 
 	/**
 	 * 接收一个可以转化成 cn.hutool.core.lang.func.VoidFunc0的Lambda表达式，和一个RuntimeException，当执行表达式抛出任何异常的时候，都会转化成运行时异常
@@ -246,6 +344,29 @@ public class CheckedUtil {
 		};
 	}
 
+	/**
+	 * 接收一个可以转化成 cn.hutool.core.lang.func.VoidFunc0的Lambda表达式，和一个可以把Exception转化成RuntimeExceptionde的表达式，当执行表达式抛出任何异常的时候，都会转化成运行时异常
+	 * 如此一来，代码中就不用显示的try-catch转化成运行时异常
+	 *
+	 * @param expression  Lambda表达式
+	 * @param rteSupplier 转化运行时异常的表达式
+	 * @return {@link VoidFunc0Rt}
+	 */
+	public static VoidFunc0Rt uncheck(VoidFunc0 expression, Supplier1<RuntimeException, Exception> rteSupplier) {
+		Objects.requireNonNull(expression, "expression can not be null");
+		return () -> {
+			try {
+				expression.call();
+			} catch (Exception e) {
+				if (rteSupplier == null) {
+					throw new RuntimeException(e);
+				} else {
+					throw rteSupplier.get(e);
+				}
+			}
+		};
+	}
+
 
 	/**
 	 * 接收一个可以转化成 cn.hutool.core.lang.func.VoidFunc1的Lambda表达式，和一个RuntimeException，当执行表达式抛出任何异常的时候，都会转化成运行时异常
@@ -272,29 +393,57 @@ public class CheckedUtil {
 		};
 	}
 
+	/**
+	 * 接收一个可以转化成 cn.hutool.core.lang.func.VoidFunc1的Lambda表达式，和一个RuntimeException，当执行表达式抛出任何异常的时候，都会转化成运行时异常
+	 * 如此一来，代码中就不用显示的try-catch转化成运行时异常
+	 *
+	 * @param expression  Lambda表达式
+	 * @param rteSupplier 转化运行时异常的表达式
+	 * @param <P>         运行时传入的参数类型
+	 * @return {@link VoidFunc1Rt}
+	 */
+	public static <P> VoidFunc1Rt<P> uncheck(VoidFunc1<P> expression, Supplier1<RuntimeException, Exception> rteSupplier) {
+		Objects.requireNonNull(expression, "expression can not be null");
+		return t -> {
+			try {
+				expression.call(t);
+			} catch (Exception e) {
+				if (rteSupplier == null) {
+					throw new RuntimeException(e);
+				} else {
+					throw rteSupplier.get(e);
+				}
+			}
+		};
+	}
+
 	public interface FuncRt<P, R> extends Func<P, R> {
-		@SuppressWarnings("unchecked")
+		@Override
 		R call(P... parameters) throws RuntimeException;
 	}
 
 	public interface Func0Rt<R> extends Func0<R> {
+		@Override
 		R call() throws RuntimeException;
 	}
 
 	public interface Func1Rt<P, R> extends Func1<P, R> {
+		@Override
 		R call(P parameter) throws RuntimeException;
 	}
 
 	public interface VoidFuncRt<P> extends VoidFunc<P> {
-		@SuppressWarnings("unchecked")
+		@Override
 		void call(P... parameters) throws RuntimeException;
 	}
 
 	public interface VoidFunc0Rt extends VoidFunc0 {
+		@Override
 		void call() throws RuntimeException;
 	}
 
 	public interface VoidFunc1Rt<P> extends VoidFunc1<P> {
+		@Override
 		void call(P parameter) throws RuntimeException;
 	}