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 2d4170b0c..58ba7444c 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
@@ -1,12 +1,13 @@
package cn.hutool.core.exceptions;
+import cn.hutool.core.lang.func.*;
+
import java.util.Objects;
-import java.util.function.*;
/**
* 方便的执行会抛出受检查类型异常的方法调用或者代码段
*
- * 该工具通过函数式的方式将那些需要抛出受检查异常的表达式或者代码段转化成一个标准的java8 functional 对象
+ * 该工具通过函数式的方式将那些需要抛出受检查异常的表达式或者代码段转化成一个 cn.hutool.core.lang.func.Func* 对象
*
*
*
@@ -24,13 +25,13 @@ import java.util.function.*;
* // use describedObject ...
*
* //上面的代码增加了异常块使得代码不那么流畅，现在可以这样写：
- * Map describedObject = CheckedUtil.uncheck(BeanUtils::describe).apply(new Object());
+ * Map describedObject = CheckedUtil.uncheck(BeanUtils::describe).call(new Object());
* // use describedObject ...
*
- * CheckedUtil.uncheck 方法接受任意可以转化成标准java8 函数式接口的 Lambda 表达式。返回对应的函数式对象。
+ * CheckedUtil.uncheck 方法接受任意可以转化成 cn.hutool.core.lang.func.Func* 函数式接口的 Lambda 表达式。返回对应的函数式对象。
* 上述代码可以理解为：
- * Function> aFunc = CheckedUtil.uncheck(BeanUtils::describe);
- * Map describedObject = aFunc.apply(传入参数);
+ * Func0> aFunc = CheckedUtil.uncheck(BeanUtils::describe);
+ * Map describedObject = aFunc.call(传入参数);
* 该aFunc对象代表的就是BeanUtils::describe这个表达式，且在内部转化了检查类型异常，不需要代码里面显示处理。
*
*
@@ -41,101 +42,100 @@ import java.util.function.*;
public class CheckedUtil {
/**
- * 接收一个可以转化成 java.util.function.Function的Lambda表达式，当执行表达式抛出任何异常的时候，都会转化成运行时异常
+ * 接收一个可以转化成 cn.hutool.core.lang.func.Func 的Lambda表达式，当执行表达式抛出任何异常的时候，都会转化成运行时异常
* 如此一来，代码中就不用显示的try-catch转化成运行时异常
*
* @param expression Lambda表达式
- * @param 运行时传入的参数类型
+ * @param 运行时传入的参数类型
* @param 最终返回的数据类型
- * @return java.util.function.Function
+ * @return cn.hutool.core.lang.func.Func
*/
- public static Function uncheck(MorFunction expression) {
+ public static FuncRt uncheck(Func expression) {
return uncheck(expression, new RuntimeException());
}
/**
- * 接收一个可以转化成 java.util.function.BiFunction的Lambda表达式当执行表达式抛出任何异常的时候，都会转化成运行时异常
+ * 接收一个可以转化成 cn.hutool.core.lang.func.Func0 的Lambda表达式，当执行表达式抛出任何异常的时候，都会转化成运行时异常
* 如此一来，代码中就不用显示的try-catch转化成运行时异常
*
- * @param expression Lambda表达式
- * @param 运行时传入的参数类型一
- * @param 运行时传入的参数类型二
+ * @param expression 运行时传入的参数类型
* @param 最终返回的数据类型
- * @return java.util.function.BiFunction
+ * @return cn.hutool.core.lang.func.Func0
*/
- public static BiFunction uncheck(BiFunction expression) {
+ public static Func0Rt uncheck(Func0 expression) {
return uncheck(expression, new RuntimeException());
}
/**
- * 接收一个可以转化成 java.util.function.Consumer的Lambda表达式，当执行表达式抛出任何异常的时候，都会转化成运行时异常
+ * 接收一个可以转化成 cn.hutool.core.lang.func.Func1 的Lambda表达式，当执行表达式抛出任何异常的时候，都会转化成运行时异常
* 如此一来，代码中就不用显示的try-catch转化成运行时异常
*
- * @param expression Lambda表达式
- * @param 运行时传入的参数类型
- * @return java.util.function.Consumer
+ * @param expression 运行时传入的参数类型
+ * @param 运行时传入的参数类型
+ * @param 最终返回的数据类型
+ * @return cn.hutool.core.lang.func.Func1
*/
- public static Consumer uncheck(MorConsumer expression) {
+ public static Func1Rt uncheck(Func1 expression) {
return uncheck(expression, new RuntimeException());
}
+
/**
- * 接收一个可以转化成 java.util.function.BiConsumer的Lambda表达式，当执行表达式抛出任何异常的时候，都会转化成运行时异常
+ * 接收一个可以转化成 cn.hutool.core.lang.func.VoidFunc 的Lambda表达式，当执行表达式抛出任何异常的时候，都会转化成运行时异常
* 如此一来，代码中就不用显示的try-catch转化成运行时异常
*
- * @param expression Lambda表达式
- * @param 运行时传入的参数类型一
- * @param 运行时传入的参数类型二
- * @return java.util.function.BiConsumer
+ * @param expression 运行时传入的参数类型
+ * @param 运行时传入的参数类型
+ * @return cn.hutool.core.lang.func.VoidFunc
*/
- public static BiConsumer uncheck(MorBiConsumer expression) {
+ public static VoidFuncRt
uncheck(VoidFunc
expression) {
return uncheck(expression, new RuntimeException());
}
/**
- * 接收一个可以转化成 java.util.function.Runnable的Lambda表达式，当执行表达式抛出任何异常的时候，都会转化成运行时异常
+ * 接收一个可以转化成 cn.hutool.core.lang.func.VoidFunc0 的Lambda表达式，当执行表达式抛出任何异常的时候，都会转化成运行时异常
* 如此一来，代码中就不用显示的try-catch转化成运行时异常
*
- * @param expression Lambda表达式
- * @return java.util.function.Runnable
+ * @param expression 运行时传入的参数类型
+ * @return cn.hutool.core.lang.func.VoidFunc0
*/
- public static Runnable uncheck(MorRunnable expression) {
+ public static VoidFunc0Rt uncheck(VoidFunc0 expression) {
return uncheck(expression, new RuntimeException());
}
/**
- * 接收一个可以转化成 java.util.function.Supplier的Lambda表达式，当执行表达式抛出任何异常的时候，都会转化成运行时异常
+ * 接收一个可以转化成 cn.hutool.core.lang.func.VoidFunc1 的Lambda表达式，当执行表达式抛出任何异常的时候，都会转化成运行时异常
* 如此一来，代码中就不用显示的try-catch转化成运行时异常
*
- * @param expression Lambda表达式
- * @param 运行时传入的参数类型
- * @return java.util.function.Supplier
+ * @param expression 运行时传入的参数类型
+ * @param 运行时传入的参数类型
+ * @return cn.hutool.core.lang.func.VoidFunc1
*/
- public static Supplier uncheck(MorSupplier expression) {
+ public static VoidFunc1Rt
uncheck(VoidFunc1
expression) {
return uncheck(expression, new RuntimeException());
}
/**
- * 接收一个可以转化成 java.util.function.Function的Lambda表达式，和一个RuntimeException，当执行表达式抛出任何异常的时候，都会转化成运行时异常
+ * 接收一个可以转化成 cn.hutool.core.lang.func.Func的Lambda表达式，和一个RuntimeException，当执行表达式抛出任何异常的时候，都会转化成运行时异常
* 如此一来，代码中就不用显示的try-catch转化成运行时异常
*
* @param expression Lambda表达式
* @param rte 期望抛出的运行时异常
- * @param 运行时传入的参数类型
+ * @param 运行时传入的参数类型
* @param 最终返回的数据类型
- * @return java.util.function.Function
+ * @return cn.hutool.core.lang.func.Func
*/
- public static Function uncheck(MorFunction expression, RuntimeException rte) {
+ public static FuncRt uncheck(Func expression, RuntimeException rte) {
Objects.requireNonNull(expression, "expression can not be null");
return t -> {
try {
- return expression.apply(t);
- } catch (Throwable throwable) {
+ return expression.call(t);
+ } catch (Exception e) {
if (rte == null) {
- throw new RuntimeException(throwable);
+ throw new RuntimeException(e);
} else {
- rte.initCause(throwable);
+ rte.initCause(e);
throw rte;
}
}
@@ -143,26 +143,24 @@ public class CheckedUtil {
}
/**
- * 接收一个可以转化成 java.util.function.BiFunction的Lambda表达式，和一个RuntimeException，当执行表达式抛出任何异常的时候，都会转化成运行时异常
+ * 接收一个可以转化成 cn.hutool.core.lang.func.Func0的Lambda表达式，和一个RuntimeException，当执行表达式抛出任何异常的时候，都会转化成运行时异常
* 如此一来，代码中就不用显示的try-catch转化成运行时异常
*
* @param expression Lambda表达式
* @param rte 期望抛出的运行时异常
- * @param 运行时传入的参数类型一
- * @param 运行时传入的参数类型二
* @param 最终返回的数据类型
- * @return java.util.function.BiFunction
+ * @return cn.hutool.core.lang.func.Func0
*/
- public static BiFunction uncheck(BiFunction expression, RuntimeException rte) {
+ public static Func0Rt uncheck(Func0 expression, RuntimeException rte) {
Objects.requireNonNull(expression, "expression can not be null");
- return (t1, t2) -> {
+ return () -> {
try {
- return expression.apply(t1, t2);
- } catch (Throwable throwable) {
+ return expression.call();
+ } catch (Exception e) {
if (rte == null) {
- throw new RuntimeException(throwable);
+ throw new RuntimeException(e);
} else {
- rte.initCause(throwable);
+ rte.initCause(e);
throw rte;
}
}
@@ -170,24 +168,25 @@ public class CheckedUtil {
}
/**
- * 接收一个可以转化成 java.util.function.Consumer的Lambda表达式，和一个RuntimeException，当执行表达式抛出任何异常的时候，都会转化成运行时异常
+ * 接收一个可以转化成 cn.hutool.core.lang.func.Func1的Lambda表达式，和一个RuntimeException，当执行表达式抛出任何异常的时候，都会转化成运行时异常
* 如此一来，代码中就不用显示的try-catch转化成运行时异常
*
* @param expression Lambda表达式
* @param rte 期望抛出的运行时异常
- * @param 运行时传入的参数类型
- * @return java.util.function.Consumer
+ * @param 运行时传入的参数类型
+ * @param 最终返回的数据类型
+ * @return cn.hutool.core.lang.func.Func1
*/
- public static Consumer uncheck(MorConsumer expression, RuntimeException rte) {
+ public static Func1Rt uncheck(Func1 expression, RuntimeException rte) {
Objects.requireNonNull(expression, "expression can not be null");
return t -> {
try {
- expression.apply(t);
- } catch (Throwable throwable) {
+ return expression.call(t);
+ } catch (Exception e) {
if (rte == null) {
- throw new RuntimeException(throwable);
+ throw new RuntimeException(e);
} else {
- rte.initCause(throwable);
+ rte.initCause(e);
throw rte;
}
}
@@ -195,134 +194,104 @@ public class CheckedUtil {
}
/**
- * 接收一个可以转化成 java.util.function.BiConsumer的Lambda表达式，和一个RuntimeException，当执行表达式抛出任何异常的时候，都会转化成运行时异常
+ * 接收一个可以转化成 cn.hutool.core.lang.func.VoidFunc的Lambda表达式，和一个RuntimeException，当执行表达式抛出任何异常的时候，都会转化成运行时异常
* 如此一来，代码中就不用显示的try-catch转化成运行时异常
*
* @param expression Lambda表达式
* @param rte 期望抛出的运行时异常
- * @param 运行时传入的参数类型一
- * @param 运行时传入的参数类型二
- * @return java.util.function.BiConsumer
+ * @param 运行时传入的参数类型
+ * @return cn.hutool.core.lang.func.VoidFunc
*/
- public static BiConsumer uncheck(MorBiConsumer expression, RuntimeException rte) {
+ public static VoidFuncRt
uncheck(VoidFunc
expression, RuntimeException rte) {
Objects.requireNonNull(expression, "expression can not be null");
- return (t, u) -> {
+ return t -> {
try {
- expression.apply(t, u);
- } catch (Throwable throwable) {
+ expression.call(t);
+ } catch (Exception e) {
if (rte == null) {
- throw new RuntimeException(throwable);
+ throw new RuntimeException(e);
} else {
- rte.initCause(throwable);
+ rte.initCause(e);
throw rte;
}
}
};
}
+
/**
- * 接收一个可以转化成 java.util.function.Runnable的Lambda表达式，和一个RuntimeException，当执行表达式抛出任何异常的时候，都会转化成运行时异常
+ * 接收一个可以转化成 cn.hutool.core.lang.func.VoidFunc0的Lambda表达式，和一个RuntimeException，当执行表达式抛出任何异常的时候，都会转化成运行时异常
* 如此一来，代码中就不用显示的try-catch转化成运行时异常
*
* @param expression Lambda表达式
* @param rte 期望抛出的运行时异常
- * @return java.util.function.Runnable
+ * @return cn.hutool.core.lang.func.VoidFunc0
*/
- public static Runnable uncheck(MorRunnable expression, RuntimeException rte) {
+ public static VoidFunc0Rt uncheck(VoidFunc0 expression, RuntimeException rte) {
Objects.requireNonNull(expression, "expression can not be null");
return () -> {
try {
- expression.apply();
- } catch (Throwable throwable) {
+ expression.call();
+ } catch (Exception e) {
if (rte == null) {
- throw new RuntimeException(throwable);
+ throw new RuntimeException(e);
} else {
- rte.initCause(throwable);
+ rte.initCause(e);
throw rte;
}
}
};
}
+
/**
- * 接收一个可以转化成 java.util.function.Supplier的Lambda表达式，和一个RuntimeException，当执行表达式抛出任何异常的时候，都会转化成运行时异常
+ * 接收一个可以转化成 cn.hutool.core.lang.func.VoidFunc1的Lambda表达式，和一个RuntimeException，当执行表达式抛出任何异常的时候，都会转化成运行时异常
* 如此一来，代码中就不用显示的try-catch转化成运行时异常
*
* @param expression Lambda表达式
* @param rte 期望抛出的运行时异常
- * @param 运行时传入的参数类型
- * @return java.util.function.Supplier
+ * @param 运行时传入的参数类型
+ * @return cn.hutool.core.lang.func.VoidFunc1
*/
- public static Supplier uncheck(MorSupplier expression, RuntimeException rte) {
+ public static VoidFunc1Rt
uncheck(VoidFunc1
expression, RuntimeException rte) {
Objects.requireNonNull(expression, "expression can not be null");
- return () -> {
+ return t -> {
try {
- return expression.apply();
- } catch (Throwable throwable) {
+ expression.call(t);
+ } catch (Exception e) {
if (rte == null) {
- throw new RuntimeException(throwable);
+ throw new RuntimeException(e);
} else {
- rte.initCause(throwable);
+ rte.initCause(e);
throw rte;
}
}
};
}
-
- /**
- * 对应java8 java.util.function.Function ,能够接受受检查异常的转化
- *
- * @param
- * @param
- */
- public interface MorFunction {
- R apply(T t) throws Throwable;
+ public interface FuncRt extends Func {
+ R call(P... parameters) throws RuntimeException;
}
- /**
- * 对应java8 java.util.function.BiFunction ,能够接受受检查异常的转化
- *
- * @param
- * @param
- * @param
- */
- public interface MorBiFunction {
- R apply(T1 t1, T2 t2) throws Throwable;
+ public interface Func0Rt extends Func0 {
+ R call() throws RuntimeException;
}
- /**
- * 对应java8 java.util.function.Consumer ,能够接受受检查异常的转化
- *
- * @param
- */
- public interface MorConsumer {
- void apply(T t) throws Throwable;
+ public interface Func1Rt extends Func1 {
+ R call(P parameter) throws RuntimeException;
}
- /**
- * 对应java8 java.util.function.BiConsumer ,能够接受受检查异常的转化
- *
- * @param
- * @param
- */
- public interface MorBiConsumer {
- void apply(T t, U u) throws Throwable;
+ public interface VoidFuncRt extends VoidFunc
{
+ void call(P... parameters) throws RuntimeException;
}
- /**
- * 对应java8 java.util.function.Runnable ,能够接受受检查异常的转化
- */
- public interface MorRunnable {
- void apply() throws Throwable;
+ public interface VoidFunc0Rt extends VoidFunc0 {
+ void call() throws RuntimeException;
}
- /**
- * 对应java8 java.util.function.Supplier ,能够接受受检查异常的转化
- *
- * @param
- */
- public interface MorSupplier {
- R apply() throws Throwable;
+ public interface VoidFunc1Rt extends VoidFunc1
{
+ void call(P parameter) throws RuntimeException;
}
+
+
}
diff --git a/hutool-core/src/test/java/cn/hutool/core/exceptions/CheckedUtilTest.java b/hutool-core/src/test/java/cn/hutool/core/exceptions/CheckedUtilTest.java
index fc62d4bf5..10b007b23 100644
--- a/hutool-core/src/test/java/cn/hutool/core/exceptions/CheckedUtilTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/exceptions/CheckedUtilTest.java
@@ -1,5 +1,7 @@
package cn.hutool.core.exceptions;
+import cn.hutool.core.lang.func.Func1;
+import cn.hutool.core.lang.func.VoidFunc0;
import org.junit.Assert;
import org.junit.Test;
@@ -17,12 +19,22 @@ import java.io.FileInputStream;
public class CheckedUtilTest {
+ @Test
+ public void sleepTest() {
+
+ VoidFunc0 func = () -> Thread.sleep(1000L);
+ func.callWithRuntimeException();
+
+
+ }
+
+
@Test
public void supplierTest() {
File noFile = new File("./no-file");
try {
//本行代码原本需要抛出受检查异常，现在只抛出运行时异常
- FileInputStream stream = CheckedUtil.uncheck(() -> new FileInputStream(noFile)).get();
+ FileInputStream stream = CheckedUtil.uncheck(() -> new FileInputStream(noFile)).call();
} catch (Exception re) {
Assert.assertTrue(re instanceof RuntimeException);
}
@@ -31,7 +43,7 @@ public class CheckedUtilTest {
@Test
public void functionTest() {
- CheckedUtil.MorFunction afunc = (funcParam) -> {
+ Func1 afunc = (funcParam) -> {
if (funcParam.length() > 5) {
throw new Exception("这是受检查异常需要屌用处显示处理");
}
@@ -43,7 +55,7 @@ public class CheckedUtilTest {
try {
//本行代码原本需要抛出受检查异常，现在只抛出运行时异常
- String reslut = CheckedUtil.uncheck(afunc).apply("hello world");
+ String reslut = CheckedUtil.uncheck(afunc).call("hello world");
} catch (Exception re) {
Assert.assertTrue(re instanceof RuntimeException);
}