From df98df70bba8bd5c0cfc924fa39bed6d7fbed038 Mon Sep 17 00:00:00 2001 From: youtiaoguagua <2049150434@qq.com> Date: Sun, 11 Sep 2022 00:16:46 +0800 Subject: [PATCH] fix(bug): change ObjectUtil.defaultIfXXX param type Supplier to Function --- .../AbstractTypeAnnotationScanner.java | 2 +- .../annotation/scanner/AnnotationScanner.java | 2 +- .../scanner/ElementAnnotationScanner.java | 2 +- .../scanner/FieldAnnotationScanner.java | 2 +- .../scanner/GenericAnnotationScanner.java | 28 ++--- .../scanner/MetaAnnotationScanner.java | 18 ++-- .../java/cn/hutool/core/date/DateTime.java | 2 +- .../core/io/FastByteArrayOutputStream.java | 2 +- .../hutool/core/lang/ResourceClassLoader.java | 2 +- .../cn/hutool/core/map/LinkedForestMap.java | 2 +- .../java/cn/hutool/core/util/ObjectUtil.java | 101 ++++++++++++++++-- .../cn/hutool/core/util/ObjectUtilTest.java | 22 ++-- 12 files changed, 140 insertions(+), 45 deletions(-) diff --git a/hutool-core/src/main/java/cn/hutool/core/annotation/scanner/AbstractTypeAnnotationScanner.java b/hutool-core/src/main/java/cn/hutool/core/annotation/scanner/AbstractTypeAnnotationScanner.java index b90035baa..8a3b2e7d1 100644 --- a/hutool-core/src/main/java/cn/hutool/core/annotation/scanner/AbstractTypeAnnotationScanner.java +++ b/hutool-core/src/main/java/cn/hutool/core/annotation/scanner/AbstractTypeAnnotationScanner.java @@ -164,7 +164,7 @@ public abstract class AbstractTypeAnnotationScanner consumer, AnnotatedElement annotatedEle, Predicate filter) { - filter = ObjectUtil.defaultIfNull(filter, annotation -> true); + filter = ObjectUtil.defaultIfNull(filter, a -> annotation -> true); final Class sourceClass = getClassFormAnnotatedElement(annotatedEle); final Deque>> classDeque = CollUtil.newLinkedList(CollUtil.newArrayList(sourceClass)); final Set> accessedTypes = new LinkedHashSet<>(); diff --git a/hutool-core/src/main/java/cn/hutool/core/annotation/scanner/AnnotationScanner.java b/hutool-core/src/main/java/cn/hutool/core/annotation/scanner/AnnotationScanner.java index cdbfad1a9..dc108cb35 100644 --- a/hutool-core/src/main/java/cn/hutool/core/annotation/scanner/AnnotationScanner.java +++ b/hutool-core/src/main/java/cn/hutool/core/annotation/scanner/AnnotationScanner.java @@ -174,7 +174,7 @@ public interface AnnotationScanner { * @param filter 注解过滤器，无法通过过滤器的注解不会被处理。该参数允许为空。 */ default void scan(BiConsumer consumer, AnnotatedElement annotatedEle, Predicate filter) { - filter = ObjectUtil.defaultIfNull(filter, annotation -> true); + filter = ObjectUtil.defaultIfNull(filter, (a)->annotation -> true); for (final Annotation annotation : annotatedEle.getAnnotations()) { if (AnnotationUtil.isNotJdkMateAnnotation(annotation.annotationType()) && filter.test(annotation)) { consumer.accept(0, annotation); diff --git a/hutool-core/src/main/java/cn/hutool/core/annotation/scanner/ElementAnnotationScanner.java b/hutool-core/src/main/java/cn/hutool/core/annotation/scanner/ElementAnnotationScanner.java index 7907c160e..88b22bc42 100644 --- a/hutool-core/src/main/java/cn/hutool/core/annotation/scanner/ElementAnnotationScanner.java +++ b/hutool-core/src/main/java/cn/hutool/core/annotation/scanner/ElementAnnotationScanner.java @@ -35,7 +35,7 @@ public class ElementAnnotationScanner implements AnnotationScanner { */ @Override public void scan(BiConsumer consumer, AnnotatedElement annotatedEle, Predicate filter) { - filter = ObjectUtil.defaultIfNull(filter, t -> true); + filter = ObjectUtil.defaultIfNull(filter,a-> t -> true); Stream.of(annotatedEle.getAnnotations()) .filter(filter) .forEach(annotation -> consumer.accept(0, annotation)); diff --git a/hutool-core/src/main/java/cn/hutool/core/annotation/scanner/FieldAnnotationScanner.java b/hutool-core/src/main/java/cn/hutool/core/annotation/scanner/FieldAnnotationScanner.java index 8357fd834..e7d87cd61 100644 --- a/hutool-core/src/main/java/cn/hutool/core/annotation/scanner/FieldAnnotationScanner.java +++ b/hutool-core/src/main/java/cn/hutool/core/annotation/scanner/FieldAnnotationScanner.java @@ -36,7 +36,7 @@ public class FieldAnnotationScanner implements AnnotationScanner { */ @Override public void scan(BiConsumer consumer, AnnotatedElement annotatedEle, Predicate filter) { - filter = ObjectUtil.defaultIfNull(filter, annotation -> true); + filter = ObjectUtil.defaultIfNull(filter, a -> annotation -> true); for (final Annotation annotation : annotatedEle.getAnnotations()) { if (AnnotationUtil.isNotJdkMateAnnotation(annotation.annotationType()) && filter.test(annotation)) { consumer.accept(0, annotation); diff --git a/hutool-core/src/main/java/cn/hutool/core/annotation/scanner/GenericAnnotationScanner.java b/hutool-core/src/main/java/cn/hutool/core/annotation/scanner/GenericAnnotationScanner.java index 9056af9cd..fe40f100e 100644 --- a/hutool-core/src/main/java/cn/hutool/core/annotation/scanner/GenericAnnotationScanner.java +++ b/hutool-core/src/main/java/cn/hutool/core/annotation/scanner/GenericAnnotationScanner.java @@ -75,16 +75,16 @@ public class GenericAnnotationScanner implements AnnotationScanner { * @param enableScanSupperInterface 是否扫描父接口 */ public GenericAnnotationScanner( - boolean enableScanMetaAnnotation, - boolean enableScanSupperClass, - boolean enableScanSupperInterface) { + boolean enableScanMetaAnnotation, + boolean enableScanSupperClass, + boolean enableScanSupperInterface) { this.metaScanner = enableScanMetaAnnotation ? new MetaAnnotationScanner() : new EmptyAnnotationScanner(); this.typeScanner = new TypeAnnotationScanner( - enableScanSupperClass, enableScanSupperInterface, a -> true, Collections.emptySet() + enableScanSupperClass, enableScanSupperInterface, a -> true, Collections.emptySet() ); this.methodScanner = new MethodAnnotationScanner( - enableScanSupperClass, enableScanSupperInterface, a -> true, Collections.emptySet() + enableScanSupperClass, enableScanSupperInterface, a -> true, Collections.emptySet() ); this.elementScanner = new ElementAnnotationScanner(); } @@ -98,7 +98,7 @@ public class GenericAnnotationScanner implements AnnotationScanner { */ @Override public void scan(BiConsumer consumer, AnnotatedElement annotatedEle, Predicate filter) { - filter = ObjectUtil.defaultIfNull(filter, t -> true); + filter = ObjectUtil.defaultIfNull(filter, a -> t -> true); if (ObjectUtil.isNull(annotatedEle)) { return; } @@ -125,10 +125,10 @@ public class GenericAnnotationScanner implements AnnotationScanner { * @param filter 注解过滤器，无法通过过滤器的注解不会被处理。该参数允许为空。 */ private void scanElements( - AnnotationScanner scanner, - BiConsumer consumer, - AnnotatedElement annotatedEle, - Predicate filter) { + AnnotationScanner scanner, + BiConsumer consumer, + AnnotatedElement annotatedEle, + Predicate filter) { // 扫描类上注解 final ListValueMap classAnnotations = new ListValueMap<>(new LinkedHashMap<>()); scanner.scan((index, annotation) -> { @@ -139,10 +139,10 @@ public class GenericAnnotationScanner implements AnnotationScanner { // 扫描元注解 classAnnotations.forEach((index, annotations) -> - annotations.forEach(annotation -> { - consumer.accept(index, annotation); - metaScanner.scan(consumer, annotation.annotationType(), filter); - }) + annotations.forEach(annotation -> { + consumer.accept(index, annotation); + metaScanner.scan(consumer, annotation.annotationType(), filter); + }) ); } diff --git a/hutool-core/src/main/java/cn/hutool/core/annotation/scanner/MetaAnnotationScanner.java b/hutool-core/src/main/java/cn/hutool/core/annotation/scanner/MetaAnnotationScanner.java index 5188a9218..a054232b2 100644 --- a/hutool-core/src/main/java/cn/hutool/core/annotation/scanner/MetaAnnotationScanner.java +++ b/hutool-core/src/main/java/cn/hutool/core/annotation/scanner/MetaAnnotationScanner.java @@ -51,7 +51,7 @@ public class MetaAnnotationScanner implements AnnotationScanner { */ @Override public boolean support(AnnotatedElement annotatedEle) { - return (annotatedEle instanceof Class && ClassUtil.isAssignable(Annotation.class, (Class)annotatedEle)); + return (annotatedEle instanceof Class && ClassUtil.isAssignable(Annotation.class, (Class) annotatedEle)); } /** @@ -80,25 +80,25 @@ public class MetaAnnotationScanner implements AnnotationScanner { @SuppressWarnings("unchecked") @Override public void scan(BiConsumer consumer, AnnotatedElement annotatedEle, Predicate filter) { - filter = ObjectUtil.defaultIfNull(filter, t -> true); + filter = ObjectUtil.defaultIfNull(filter, a -> t -> true); Set> accessed = new HashSet<>(); - final Deque>> deque = CollUtil.newLinkedList(CollUtil.newArrayList((Class)annotatedEle)); + final Deque>> deque = CollUtil.newLinkedList(CollUtil.newArrayList((Class) annotatedEle)); int distance = 0; do { final List> annotationTypes = deque.removeFirst(); for (final Class type : annotationTypes) { final List metaAnnotations = Stream.of(type.getAnnotations()) - .filter(a -> !AnnotationUtil.isJdkMetaAnnotation(a.annotationType())) - .filter(filter) - .collect(Collectors.toList()); + .filter(a -> !AnnotationUtil.isJdkMetaAnnotation(a.annotationType())) + .filter(filter) + .collect(Collectors.toList()); for (final Annotation metaAnnotation : metaAnnotations) { consumer.accept(distance, metaAnnotation); } accessed.add(type); List> next = metaAnnotations.stream() - .map(Annotation::annotationType) - .filter(t -> !accessed.contains(t)) - .collect(Collectors.toList()); + .map(Annotation::annotationType) + .filter(t -> !accessed.contains(t)) + .collect(Collectors.toList()); if (CollUtil.isNotEmpty(next)) { deque.addLast(next); } diff --git a/hutool-core/src/main/java/cn/hutool/core/date/DateTime.java b/hutool-core/src/main/java/cn/hutool/core/date/DateTime.java index 2956eade4..6bf90e214 100644 --- a/hutool-core/src/main/java/cn/hutool/core/date/DateTime.java +++ b/hutool-core/src/main/java/cn/hutool/core/date/DateTime.java @@ -160,7 +160,7 @@ public class DateTime extends Date { * @since 4.1.2 */ public DateTime(Date date, TimeZone timeZone) { - this(ObjectUtil.defaultIfNull(date, Date::new).getTime(), timeZone); + this(ObjectUtil.defaultIfNull(date, new Date()).getTime(), timeZone); } /** diff --git a/hutool-core/src/main/java/cn/hutool/core/io/FastByteArrayOutputStream.java b/hutool-core/src/main/java/cn/hutool/core/io/FastByteArrayOutputStream.java index b32192d8b..68d78b489 100644 --- a/hutool-core/src/main/java/cn/hutool/core/io/FastByteArrayOutputStream.java +++ b/hutool-core/src/main/java/cn/hutool/core/io/FastByteArrayOutputStream.java @@ -117,7 +117,7 @@ public class FastByteArrayOutputStream extends OutputStream { */ public String toString(Charset charset) { return new String(toByteArray(), - ObjectUtil.defaultIfNull(charset, CharsetUtil::defaultCharset)); + ObjectUtil.defaultIfNull(charset, CharsetUtil.defaultCharset())); } } diff --git a/hutool-core/src/main/java/cn/hutool/core/lang/ResourceClassLoader.java b/hutool-core/src/main/java/cn/hutool/core/lang/ResourceClassLoader.java index 509efa967..5f83efcfa 100644 --- a/hutool-core/src/main/java/cn/hutool/core/lang/ResourceClassLoader.java +++ b/hutool-core/src/main/java/cn/hutool/core/lang/ResourceClassLoader.java @@ -31,7 +31,7 @@ public class ResourceClassLoader extends SecureClassLoader { */ public ResourceClassLoader(ClassLoader parentClassLoader, Map resourceMap) { super(ObjectUtil.defaultIfNull(parentClassLoader, ClassLoaderUtil::getClassLoader)); - this.resourceMap = ObjectUtil.defaultIfNull(resourceMap, HashMap::new); + this.resourceMap = ObjectUtil.defaultIfNull(resourceMap, new HashMap<>()); this.cacheClassMap = new HashMap<>(); } diff --git a/hutool-core/src/main/java/cn/hutool/core/map/LinkedForestMap.java b/hutool-core/src/main/java/cn/hutool/core/map/LinkedForestMap.java index e24b6f391..eddb4a375 100644 --- a/hutool-core/src/main/java/cn/hutool/core/map/LinkedForestMap.java +++ b/hutool-core/src/main/java/cn/hutool/core/map/LinkedForestMap.java @@ -442,7 +442,7 @@ public class LinkedForestMap implements ForestMap { */ TreeEntryNode traverseParentNodes( boolean includeCurrent, Consumer> consumer, Predicate> breakTraverse) { - breakTraverse = ObjectUtil.defaultIfNull(breakTraverse, n -> false); + breakTraverse = ObjectUtil.defaultIfNull(breakTraverse, a -> n -> false); TreeEntryNode curr = includeCurrent ? this : this.parent; while (ObjectUtil.isNotNull(curr)) { consumer.accept(curr); diff --git a/hutool-core/src/main/java/cn/hutool/core/util/ObjectUtil.java b/hutool-core/src/main/java/cn/hutool/core/util/ObjectUtil.java index bc064f864..dcae1f33d 100644 --- a/hutool-core/src/main/java/cn/hutool/core/util/ObjectUtil.java +++ b/hutool-core/src/main/java/cn/hutool/core/util/ObjectUtil.java @@ -8,11 +8,8 @@ import cn.hutool.core.map.MapUtil; import java.lang.reflect.Array; import java.math.BigDecimal; -import java.util.Collection; -import java.util.Enumeration; -import java.util.Iterator; -import java.util.Map; -import java.util.Objects; +import java.util.*; +import java.util.function.Function; import java.util.function.Supplier; /** @@ -310,6 +307,7 @@ public class ObjectUtil { * @throws NullPointerException {@code defaultValueSupplier == null} 时，抛出 * @since 5.7.20 */ + @Deprecated public static T defaultIfNull(T source, Supplier defaultValueSupplier) { if (isNull(source)) { return defaultValueSupplier.get(); @@ -317,6 +315,23 @@ public class ObjectUtil { return source; } + /** + * 如果被检查对象为 {@code null}， 返回默认值（由 defaultValueSupplier 提供）；否则直接返回 + * + * @param source 被检查对象 + * @param defaultValueSupplier 默认值提供者 + * @param 对象类型 + * @return 被检查对象为{@code null}返回默认值，否则返回自定义handle处理后的返回值 + * @throws NullPointerException {@code defaultValueSupplier == null} 时，抛出 + * @since 5.7.20 + */ + public static T defaultIfNull(T source, Function defaultValueSupplier) { + if (isNull(source)) { + return defaultValueSupplier.apply(null); + } + return source; + } + /** * 如果给定对象为{@code null} 返回默认值, 如果不为null 返回自定义handle处理后的返回值 * @@ -327,6 +342,7 @@ public class ObjectUtil { * @return 处理后的返回值 * @since 5.4.6 */ + @Deprecated public static T defaultIfNull(Object source, Supplier handle, final T defaultValue) { if (isNotNull(source)) { return handle.get(); @@ -334,6 +350,41 @@ public class ObjectUtil { return defaultValue; } + /** + * 如果给定对象为{@code null} 返回默认值, 如果不为null 返回自定义handle处理后的返回值 + * + * @param source Object 类型对象 + * @param handle 非空时自定义的处理方法 + * @param defaultValue 默认为空的返回值 + * @param 被检查对象为{@code null}返回默认值，否则返回自定义handle处理后的返回值 + * @return 处理后的返回值 + * @since 5.4.6 + */ + public static T defaultIfNull(R source, Function handle, final T defaultValue) { + if (isNotNull(source)) { + return handle.apply(source); + } + return defaultValue; + } + + /** + * 如果给定对象为{@code null}或者""返回默认值, 否则返回自定义handle处理后的返回值 + * + * @param str String 类型 + * @param handle 自定义的处理方法 + * @param defaultValue 默认为空的返回值 + * @param 被检查对象为{@code null}或者 ""返回默认值，否则返回自定义handle处理后的返回值 + * @return 处理后的返回值 + * @since 5.4.6 + */ + @Deprecated + public static T defaultIfEmpty(String str, Supplier handle, final T defaultValue) { + if (StrUtil.isNotEmpty(str)) { + return handle.get(); + } + return defaultValue; + } + /** * 如果给定对象为{@code null}或者""返回默认值, 否则返回自定义handle处理后的返回值 * @@ -344,9 +395,9 @@ public class ObjectUtil { * @return 处理后的返回值 * @since 5.4.6 */ - public static T defaultIfEmpty(String str, Supplier handle, final T defaultValue) { + public static T defaultIfEmpty(String str, Function handle, final T defaultValue) { if (StrUtil.isNotEmpty(str)) { - return handle.get(); + return handle.apply(str); } return defaultValue; } @@ -382,6 +433,7 @@ public class ObjectUtil { * @throws NullPointerException {@code defaultValueSupplier == null} 时，抛出 * @since 5.7.20 */ + @Deprecated public static T defaultIfEmpty(T str, Supplier defaultValueSupplier) { if (StrUtil.isEmpty(str)) { return defaultValueSupplier.get(); @@ -389,6 +441,23 @@ public class ObjectUtil { return str; } + /** + * 如果被检查对象为 {@code null} 或 "" 时，返回默认值（由 defaultValueSupplier 提供）；否则直接返回 + * + * @param str 被检查对象 + * @param defaultValueSupplier 默认值提供者 + * @param 对象类型（必须实现CharSequence接口） + * @return 被检查对象为{@code null}返回默认值，否则返回自定义handle处理后的返回值 + * @throws NullPointerException {@code defaultValueSupplier == null} 时，抛出 + * @since 5.7.20 + */ + public static T defaultIfEmpty(T str, Function defaultValueSupplier) { + if (StrUtil.isEmpty(str)) { + return defaultValueSupplier.apply(null); + } + return str; + } + /** * 如果给定对象为{@code null}或者""或者空白符返回默认值 * @@ -420,6 +489,7 @@ public class ObjectUtil { * @throws NullPointerException {@code defaultValueSupplier == null} 时，抛出 * @since 5.7.20 */ + @Deprecated public static T defaultIfBlank(T str, Supplier defaultValueSupplier) { if (StrUtil.isBlank(str)) { return defaultValueSupplier.get(); @@ -427,6 +497,23 @@ public class ObjectUtil { return str; } + /** + * 如果被检查对象为 {@code null} 或 "" 或 空白字符串时，返回默认值（由 defaultValueSupplier 提供）；否则直接返回 + * + * @param str 被检查对象 + * @param defaultValueSupplier 默认值提供者 + * @param 对象类型（必须实现CharSequence接口） + * @return 被检查对象为{@code null}返回默认值，否则返回自定义handle处理后的返回值 + * @throws NullPointerException {@code defaultValueSupplier == null} 时，抛出 + * @since 5.7.20 + */ + public static T defaultIfBlank(T str, Function defaultValueSupplier) { + if (StrUtil.isBlank(str)) { + return defaultValueSupplier.apply(null); + } + return str; + } + /** * 克隆对象
* 如果对象实现Cloneable接口，调用其clone方法
diff --git a/hutool-core/src/test/java/cn/hutool/core/util/ObjectUtilTest.java b/hutool-core/src/test/java/cn/hutool/core/util/ObjectUtilTest.java index 175efa1ef..e3658babe 100644 --- a/hutool-core/src/test/java/cn/hutool/core/util/ObjectUtilTest.java +++ b/hutool-core/src/test/java/cn/hutool/core/util/ObjectUtilTest.java @@ -15,15 +15,15 @@ import java.util.Map; public class ObjectUtilTest { @Test - public void equalsTest(){ + public void equalsTest() { Object a = null; Object b = null; Assert.assertTrue(ObjectUtil.equals(a, b)); } @Test - public void lengthTest(){ - int[] array = new int[]{1,2,3,4,5}; + public void lengthTest() { + int[] array = new int[]{1, 2, 3, 4, 5}; int length = ObjectUtil.length(array); Assert.assertEquals(5, length); @@ -36,8 +36,8 @@ public class ObjectUtilTest { } @Test - public void containsTest(){ - int[] array = new int[]{1,2,3,4,5}; + public void containsTest() { + int[] array = new int[]{1, 2, 3, 4, 5}; final boolean contains = ObjectUtil.contains(array, 1); Assert.assertTrue(contains); @@ -73,6 +73,14 @@ public class ObjectUtilTest { Instant result2 = ObjectUtil.defaultIfNull(nullValue, () -> DateUtil.parse(nullValue, DatePattern.NORM_DATETIME_PATTERN).toInstant(), Instant.now()); Assert.assertNotNull(result2); + + Obj obj = new Obj(); + Obj objNull = null; + String result3 = ObjectUtil.defaultIfNull(obj, (a) -> obj.doSomeThing(), "fail"); + Assert.assertNotNull(result3); + + String result4 = ObjectUtil.defaultIfNull(objNull, Obj::doSomeThing, "fail"); + Assert.assertNotNull(result4); } @Test @@ -88,14 +96,14 @@ public class ObjectUtilTest { } @Test - public void isBasicTypeTest(){ + public void isBasicTypeTest() { int a = 1; final boolean basicType = ObjectUtil.isBasicType(a); Assert.assertTrue(basicType); } @Test - public void isNotNullTest(){ + public void isNotNullTest() { String a = null; Assert.assertFalse(ObjectUtil.isNotNull(a)); }