自定义函数式接口

/**  
* 分支处理接口  
**/  
@FunctionalInterface  
public interface BranchFunction {  
/**  
* 分支操作  
* @param trueHandle 为true时要进行的操作  
* @param falseHandle 为false时要进行的操作  
**/  
void trueOrFalseHandle(Runnable trueHandle, Runnable falseHandle);  
}

/**  
* Lambda 异常处理  
**/  
@FunctionalInterface  
public interface LambdaThrowException {  
void apply() throws Exception;  
}

/**  
* 空值与非空值分支处理  
*/  
@FunctionalInterface  
public interface PresentOrElseFunction<T> {  
  
/**  
* 值不为空时执行消费操作  
* 值为空时执行其他的操作  
*  
* @param action 值不为空时，执行的消费操作  
* @param emptyAction 值为空时，执行的操作  
**/  
void presentOrElseHandle(Consumer<? super T> action, Runnable emptyAction);    
}

/**  
* 抛异常接口  
**/  
@FunctionalInterface  
public interface ThrowExceptionFunction {  
/**  
* 抛出异常信息  
* @param message 异常信息  
**/  
void throwMessage(String message);  
}

package org.example.common.util;  
  
import lombok.extern.slf4j.Slf4j;  
import org.example.common.handler.*;  
  
  
@Slf4j  
public class HandlerUtils {  
  
/**  
* 如果参数为true抛出异常  
* @return ThrowExceptionFunction  
*/  
public static ThrowExceptionFunction isTure(boolean param) {  
return (errorMessage) -> {  
if (param) {  
throw new RuntimeException(errorMessage);  
}  
};  
}
  
/**  
* 无参数异常捕获  
* @param lambdaThrowException 结构体  
*/  
public static void noArgsConstructor(LambdaThrowException lambdaThrowException) {  
try {  
lambdaThrowException.apply();  
} catch (Exception param) {  
param.printStackTrace();  
throw new RuntimeException(param);  
}  
;  
}  
  
/**  
* 有参数异常捕获  
* @param lambdaThrowException 结构体  
* @param var 参数内容  
*/  
public static void containArgsConstructor(LambdaThrowException lambdaThrowException, String var) {  
try {  
lambdaThrowException.apply();  
} catch (Exception param) {  
log.error(var);  
param.printStackTrace();  
throw new RuntimeException(param);  
}  
}  
  
/**  
* 参数为true或false时，分别进行不同的操作  
* @return BranchHandle  
*/  
public static BranchFunction isTureOrFalse(boolean param) {  
return (trueHandle, falseHandle) -> {  
if (param) {  
trueHandle.run();  
} else {  
falseHandle.run();  
}  
};  
}  
  
/**  
* 参数为true或false时，分别进行不同的操作  
* @return PresentOrElseHandler  
*/  
public static PresentOrElseFunction<?> isBlankOrNoBlank(String str) {  
return (consumer, runnable) -> {  
if (str == null || str.length() == 0) {  
runnable.run();  
} else {  
consumer.accept(str);  
}  
};  
}  
}