精简XXXTypeGetter

hutool-core/src/main/java/cn/hutool/core/collection/ListUtil.java

@@ -177,7 +177,8 @@ public class ListUtil {
 
 	/**
 	 * 数组转为一个不可变List<br>
-	 * 类似于Java9中的List.of
+	 * 类似于Java9中的List.of<br>
+	 * 不同于Arrays.asList，此方法的原数组修改时，并不会影响List。
 	 *
 	 * @param ts  对象
 	 * @param <T> 对象类型
@@ -708,7 +709,7 @@ public class ListUtil {
 	 * @since 6.0.0
 	 */
 	@SafeVarargs
-	public static <T> List<T> splice(List<T> list, int start, int deleteCount, T... items) {
+	public static <T> List<T> splice(final List<T> list, int start, int deleteCount, final T... items) {
 		if (CollUtil.isEmpty(list)) {
 			return zero();
 		}

hutool-core/src/main/java/cn/hutool/core/convert/Convert.java

@@ -533,7 +533,7 @@ public class Convert {
 	@SuppressWarnings("unchecked")
 	public static <E extends Enum<E>> E toEnum(final Class<E> clazz, final Object value, final E defaultValue) {
 		try{
-			return (E) (new EnumConverter()).convert(clazz, value);
+			return (E) EnumConverter.INSTANCE.convert(clazz, value);
 		} catch (final Exception ignore){
 			return defaultValue;
 		}
@@ -615,7 +615,7 @@ public class Convert {
 	 * @return {@link Map}
 	 * @since 4.6.8
 	 */
-	public static <K, V> Map<K, V> toMap(Class<K> keyType, Class<V> valueType, Object value) {
+	public static <K, V> Map<K, V> toMap(final Class<K> keyType, final Class<V> valueType, final Object value) {
 		if (value instanceof Map) {
 			return toMap(value.getClass(), keyType, valueType, value);
 		} else {
@@ -635,7 +635,7 @@ public class Convert {
 	 * @return {@link Map}
 	 */
 	@SuppressWarnings({"unchecked"})
-	public static <K, V> Map<K, V> toMap(Class<?> mapType, Class<K> keyType, Class<V> valueType, Object value) {
+	public static <K, V> Map<K, V> toMap(final Class<?> mapType, final Class<K> keyType, final Class<V> valueType, final Object value) {
 		return (Map<K, V>) MapConverter.INSTANCE.convert(mapType, keyType, valueType, value);
 	}
 
@@ -1049,7 +1049,6 @@ public class Convert {
 
 	/**
 	 * 中文大写数字金额转换为数字，返回结果以元为单位的BigDecimal类型数字
-	 *
 	 * 如：
 	 * 	“陆万柒仟伍佰伍拾陆元叁角贰分”返回“67556.32”
 	 * 	“叁角贰分”返回“0.32”

hutool-core/src/main/java/cn/hutool/core/io/resource/ResourceUtil.java

@@ -10,6 +10,7 @@ import cn.hutool.core.text.StrUtil;
 import cn.hutool.core.net.URLUtil;
 
 import java.io.BufferedReader;
+import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.URL;
@@ -210,4 +211,26 @@ public class ResourceUtil {
 		}
 		return new ClassPathResource(path);
 	}
+
+	/**
+	 * 获取{@link UrlResource} 资源对象
+	 *
+	 * @param url URL
+	 * @return {@link Resource} 资源对象
+	 * @since 6.0.0
+	 */
+	public static Resource getResource(final URL url) {
+		return new UrlResource(url);
+	}
+
+	/**
+	 * 获取{@link FileResource} 资源对象
+	 *
+	 * @param file {@link File}
+	 * @return {@link Resource} 资源对象
+	 * @since 6.0.0
+	 */
+	public static Resource getResource(final File file) {
+		return new FileResource(file);
+	}
 }

hutool-core/src/main/java/cn/hutool/core/lang/getter/ArrayTypeGetter.java

@@ -1,102 +0,0 @@
-package cn.hutool.core.lang.getter;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-
-/**
- * 数组类型的Get接口
- * @author Looly
- *
- */
-public interface ArrayTypeGetter {
-	/*-------------------------- 数组类型 start -------------------------------*/
-
-	/**
-	 * 获取Object型属性值数组
-	 *
-	 * @param key 属性名
-	 * @return 属性值列表
-	 */
-	String[] getObjs(String key);
-
-	/**
-	 * 获取String型属性值数组
-	 *
-	 * @param key 属性名
-	 * @return 属性值列表
-	 */
-	String[] getStrs(String key);
-
-	/**
-	 * 获取Integer型属性值数组
-	 *
-	 * @param key 属性名
-	 * @return 属性值列表
-	 */
-	Integer[] getInts(String key);
-
-	/**
-	 * 获取Short型属性值数组
-	 *
-	 * @param key 属性名
-	 * @return 属性值列表
-	 */
-	Short[] getShorts(String key);
-
-	/**
-	 * 获取Boolean型属性值数组
-	 *
-	 * @param key 属性名
-	 * @return 属性值列表
-	 */
-	Boolean[] getBools(String key);
-
-	/**
-	 * 获取Long型属性值数组
-	 *
-	 * @param key 属性名
-	 * @return 属性值列表
-	 */
-	Long[] getLongs(String key);
-
-	/**
-	 * 获取Character型属性值数组
-	 *
-	 * @param key 属性名
-	 * @return 属性值列表
-	 */
-	Character[] getChars(String key);
-
-	/**
-	 * 获取Double型属性值数组
-	 *
-	 * @param key 属性名
-	 * @return 属性值列表
-	 */
-	Double[] getDoubles(String key);
-
-	/**
-	 * 获取Byte型属性值数组
-	 *
-	 * @param key 属性名
-	 * @return 属性值列表
-	 */
-	Byte[] getBytes(String key);
-
-	/**
-	 * 获取BigInteger型属性值数组
-	 *
-	 * @param key 属性名
-	 * @return 属性值列表
-	 */
-	BigInteger[] getBigIntegers(String key);
-
-	/**
-	 * 获取BigDecimal型属性值数组
-	 *
-	 * @param key 属性名
-	 * @return 属性值列表
-	 */
-	BigDecimal[] getBigDecimals(String key);
-	/*-------------------------- 数组类型 end -------------------------------*/
-}

hutool-core/src/main/java/cn/hutool/core/lang/getter/BasicTypeGetter.java

@@ -1,130 +0,0 @@
-package cn.hutool.core.lang.getter;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.util.Date;
-
-/**
- * 基本类型的getter接口<br>
- * 提供一个统一的接口定义返回不同类型的值（基本类型）<br>
- *
- * @author Looly
- */
-public interface BasicTypeGetter<K> {
-	/*-------------------------- 基本类型 start -------------------------------*/
-
-	/**
-	 * 获取Object属性值
-	 *
-	 * @param key 属性名
-	 * @return 属性值
-	 */
-	Object getObj(K key);
-
-	/**
-	 * 获取字符串型属性值
-	 *
-	 * @param key 属性名
-	 * @return 属性值
-	 */
-	String getStr(K key);
-
-	/**
-	 * 获取int型属性值
-	 *
-	 * @param key 属性名
-	 * @return 属性值
-	 */
-	Integer getInt(K key);
-
-	/**
-	 * 获取short型属性值
-	 *
-	 * @param key 属性名
-	 * @return 属性值
-	 */
-	Short getShort(K key);
-
-	/**
-	 * 获取boolean型属性值
-	 *
-	 * @param key 属性名
-	 * @return 属性值
-	 */
-	Boolean getBool(K key);
-
-	/**
-	 * 获取long型属性值
-	 *
-	 * @param key 属性名
-	 * @return 属性值
-	 */
-	Long getLong(K key);
-
-	/**
-	 * 获取char型属性值
-	 *
-	 * @param key 属性名
-	 * @return 属性值
-	 */
-	Character getChar(K key);
-
-	/**
-	 * 获取float型属性值<br>
-	 *
-	 * @param key 属性名
-	 * @return 属性值
-	 */
-	Float getFloat(K key);
-
-	/**
-	 * 获取double型属性值
-	 *
-	 * @param key 属性名
-	 * @return 属性值
-	 */
-	Double getDouble(K key);
-
-	/**
-	 * 获取byte型属性值
-	 *
-	 * @param key 属性名
-	 * @return 属性值
-	 */
-	Byte getByte(K key);
-
-	/**
-	 * 获取BigDecimal型属性值
-	 *
-	 * @param key 属性名
-	 * @return 属性值
-	 */
-	BigDecimal getBigDecimal(K key);
-
-	/**
-	 * 获取BigInteger型属性值
-	 *
-	 * @param key 属性名
-	 * @return 属性值
-	 */
-	BigInteger getBigInteger(K key);
-
-	/**
-	 * 获得Enum类型的值
-	 *
-	 * @param <E> 枚举类型
-	 * @param clazz Enum的Class
-	 * @param key KEY
-	 * @return Enum类型的值，无则返回Null
-	 */
-	<E extends Enum<E>> E getEnum(Class<E> clazz, K key);
-
-	/**
-	 * 获取Date类型值
-	 *
-	 * @param key 属性名
-	 * @return Date类型属性值
-	 */
-	Date getDate(K key);
-	/*-------------------------- 基本类型 end -------------------------------*/
-}

hutool-core/src/main/java/cn/hutool/core/lang/getter/GroupedTypeGetter.java

@@ -1,103 +1,296 @@
 package cn.hutool.core.lang.getter;
 
+import cn.hutool.core.convert.Convert;
+
+import java.lang.reflect.Type;
 import java.math.BigDecimal;
 import java.math.BigInteger;
 
 /**
  * 基于分组的Get接口
- * @author Looly
  *
+ * @param <K> 键类型
+ * @param <G> 分组键类型
+ * @author Looly
+ * @since 6.0.0
  */
-public interface GroupedTypeGetter {
-	/*-------------------------- 基本类型 start -------------------------------*/
+public interface GroupedTypeGetter<K, G> {
+
 	/**
-	 * 获取字符串型属性值<br>
+	 * 获取Object属性值，最原始的对象获取，没有任何转换或类型判断
 	 *
-	 * @param key 属性名
+	 * @param key          属性名
+	 * @param group        分组
+	 * @param defaultValue 默认值
+	 * @return 属性值
+	 */
+	Object getObjByGroup(K key, G group, Object defaultValue);
+
+	/**
+	 * 获取Object属性值，最原始的对象获取，没有任何转换或类型判断
+	 *
+	 * @param key   属性名
 	 * @param group 分组
 	 * @return 属性值
 	 */
-	String getStrByGroup(String key, String group);
+	default Object getObjByGroup(final K key, final G group) {
+		return getObjByGroup(key, group, null);
+	}
+
+	/**
+	 * 获取指定类型的值，默认自动转换值类型
+	 *
+	 * @param <T>   目标类型
+	 * @param key   键
+	 * @param group 分组
+	 * @param type  目标类型
+	 * @return 结果值
+	 */
+	default <T> T getByGroup(final K key, final G group, final Type type) {
+		return getByGroup(key, group, type, null);
+	}
+
+	/**
+	 * 获取指定类型的值，默认自动转换值类型
+	 *
+	 * @param <T>          目标类型
+	 * @param key          键
+	 * @param group        分组
+	 * @param type         目标类型
+	 * @param defaultValue 默认值
+	 * @return 结果值
+	 */
+	default <T> T getByGroup(final K key, final G group, final Type type, final T defaultValue) {
+		return Convert.convert(type, getObjByGroup(key, group), defaultValue);
+	}
+
+	/**
+	 * 获取字符串型属性值
+	 *
+	 * @param key          属性名
+	 * @param group        分组
+	 * @param defaultValue 默认值
+	 * @return 属性值
+	 */
+	default String getStrByGroup(final K key, final G group, final String defaultValue) {
+		return getByGroup(key, group, String.class, defaultValue);
+	}
+
+	/**
+	 * 获取字符串型属性值
+	 *
+	 * @param key   属性名
+	 * @param group 分组
+	 * @return 属性值
+	 */
+	default String getStrByGroup(final K key, final G group) {
+		return getStrByGroup(key, group, null);
+	}
 
 	/**
 	 * 获取int型属性值<br>
 	 *
-	 * @param key 属性名
+	 * @param key          属性名
+	 * @param group        分组
+	 * @param defaultValue 默认值
+	 * @return 属性值
+	 */
+	default Integer getIntByGroup(final K key, final G group, final Integer defaultValue) {
+		return getByGroup(key, group, Integer.class, defaultValue);
+	}
+
+	/**
+	 * 获取int型属性值<br>
+	 *
+	 * @param key   属性名
 	 * @param group 分组
 	 * @return 属性值
 	 */
-	Integer getIntByGroup(String key, String group);
+	default Integer getIntByGroup(final K key, final G group) {
+		return getIntByGroup(key, group, null);
+	}
 
 	/**
 	 * 获取short型属性值<br>
 	 *
-	 * @param key 属性名
+	 * @param key          属性名
+	 * @param group        分组
+	 * @param defaultValue 默认值
+	 * @return 属性值
+	 */
+	default Short getShortByGroup(final K key, final G group, final Short defaultValue) {
+		return getByGroup(key, group, Short.class, defaultValue);
+	}
+
+	/**
+	 * 获取short型属性值<br>
+	 *
+	 * @param key   属性名
 	 * @param group 分组
 	 * @return 属性值
 	 */
-	Short getShortByGroup(String key, String group);
+	default Short getShortByGroup(final K key, final G group) {
+		return getShortByGroup(key, group, null);
+	}
 
 	/**
 	 * 获取boolean型属性值<br>
 	 *
-	 * @param key 属性名
+	 * @param key          属性名
+	 * @param group        分组
+	 * @param defaultValue 默认值
+	 * @return 属性值
+	 */
+	default Boolean getBoolByGroup(final K key, final G group, final Boolean defaultValue) {
+		return getByGroup(key, group, Boolean.class, defaultValue);
+	}
+
+	/**
+	 * 获取boolean型属性值<br>
+	 *
+	 * @param key   属性名
 	 * @param group 分组
 	 * @return 属性值
 	 */
-	Boolean getBoolByGroup(String key, String group);
+	default Boolean getBoolByGroup(final K key, final G group) {
+		return getBoolByGroup(key, group, null);
+	}
 
 	/**
 	 * 获取Long型属性值<br>
 	 *
-	 * @param key 属性名
+	 * @param key          属性名
+	 * @param group        分组
+	 * @param defaultValue 默认值
+	 * @return 属性值
+	 */
+	default Long getLongByGroup(final K key, final G group, final Long defaultValue) {
+		return getByGroup(key, group, Long.class, defaultValue);
+	}
+
+	/**
+	 * 获取Long型属性值<br>
+	 *
+	 * @param key   属性名
 	 * @param group 分组
 	 * @return 属性值
 	 */
-	Long getLongByGroup(String key, String group);
+	default Long getLongByGroup(final K key, final G group) {
+		return getLongByGroup(key, group, null);
+	}
 
 	/**
 	 * 获取char型属性值<br>
 	 *
-	 * @param key 属性名
+	 * @param key          属性名
+	 * @param group        分组
+	 * @param defaultValue 默认值
+	 * @return 属性值
+	 */
+	default Character getCharByGroup(final K key, final G group, final Character defaultValue) {
+		return getByGroup(key, group, Character.class, defaultValue);
+	}
+
+	/**
+	 * 获取char型属性值<br>
+	 *
+	 * @param key   属性名
 	 * @param group 分组
 	 * @return 属性值
 	 */
-	Character getCharByGroup(String key, String group);
+	default Character getCharByGroup(final K key, final G group) {
+		return getCharByGroup(key, group, null);
+	}
 
 	/**
 	 * 获取double型属性值<br>
 	 *
-	 * @param key 属性名
+	 * @param key          属性名
+	 * @param group        分组
+	 * @param defaultValue 默认值
+	 * @return 属性值
+	 */
+	default Double getDoubleByGroup(final K key, final G group, final Double defaultValue) {
+		return getByGroup(key, group, Double.class, defaultValue);
+	}
+
+	/**
+	 * 获取double型属性值<br>
+	 *
+	 * @param key   属性名
 	 * @param group 分组
 	 * @return 属性值
 	 */
-	Double getDoubleByGroup(String key, String group);
+	default Double getDoubleByGroup(final K key, final G group) {
+		return getDoubleByGroup(key, group, null);
+	}
 
 	/**
 	 * 获取byte型属性值<br>
 	 *
-	 * @param key 属性名
+	 * @param key          属性名
+	 * @param group        分组
+	 * @param defaultValue 默认值
+	 * @return 属性值
+	 */
+	default Byte getByteByGroup(final K key, final G group, final Byte defaultValue) {
+		return getByGroup(key, group, Byte.class, defaultValue);
+	}
+
+	/**
+	 * 获取byte型属性值<br>
+	 *
+	 * @param key   属性名
 	 * @param group 分组
 	 * @return 属性值
 	 */
-	Byte getByteByGroup(String key, String group);
+	default Byte getByteByGroup(final K key, final G group) {
+		return getByteByGroup(key, group, null);
+	}
 
 	/**
 	 * 获取BigDecimal型属性值<br>
 	 *
-	 * @param key 属性名
+	 * @param key          属性名
+	 * @param group        分组
+	 * @param defaultValue 默认值
+	 * @return 属性值
+	 */
+	default BigDecimal getBigDecimalByGroup(final K key, final G group, final BigDecimal defaultValue) {
+		return getByGroup(key, group, BigDecimal.class, defaultValue);
+	}
+
+	/**
+	 * 获取BigDecimal型属性值<br>
+	 *
+	 * @param key   属性名
 	 * @param group 分组
 	 * @return 属性值
 	 */
-	BigDecimal getBigDecimalByGroup(String key, String group);
+	default BigDecimal getBigDecimalByGroup(final K key, final G group) {
+		return getBigDecimalByGroup(key, group, null);
+	}
 
 	/**
 	 * 获取BigInteger型属性值<br>
 	 *
-	 * @param key 属性名
+	 * @param key          属性名
+	 * @param group        分组
+	 * @param defaultValue 默认值
+	 * @return 属性值
+	 */
+	default BigInteger getBigIntegerByGroup(final K key, final G group, final BigInteger defaultValue) {
+		return getByGroup(key, group, BigInteger.class, defaultValue);
+	}
+
+	/**
+	 * 获取BigInteger型属性值<br>
+	 *
+	 * @param key   属性名
 	 * @param group 分组
 	 * @return 属性值
 	 */
-	BigInteger getBigIntegerByGroup(String key, String group);
-	/*-------------------------- 基本类型 end -------------------------------*/
+	default BigInteger getBigIntegerByGroup(final K key, final G group) {
+		return getBigIntegerByGroup(key, group, null);
+	}
 }

hutool-core/src/main/java/cn/hutool/core/lang/getter/ListTypeGetter.java

@@ -1,102 +0,0 @@
-package cn.hutool.core.lang.getter;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.util.List;
-
-/**
- * 列表类型的Get接口
- * @author Looly
- *
- */
-public interface ListTypeGetter {
-	/*-------------------------- List类型 start -------------------------------*/
-	/**
-	 * 获取Object型属性值列表
-	 *
-	 * @param key 属性名
-	 * @return 属性值列表
-	 */
-	List<Object> getObjList(String key);
-
-	/**
-	 * 获取String型属性值列表
-	 *
-	 * @param key 属性名
-	 * @return 属性值列表
-	 */
-	List<String> getStrList(String key);
-
-	/**
-	 * 获取Integer型属性值列表
-	 *
-	 * @param key 属性名
-	 * @return 属性值列表
-	 */
-	List<Integer> getIntList(String key);
-
-	/**
-	 * 获取Short型属性值列表
-	 *
-	 * @param key 属性名
-	 * @return 属性值列表
-	 */
-	List<Short> getShortList(String key);
-
-	/**
-	 * 获取Boolean型属性值列表
-	 *
-	 * @param key 属性名
-	 * @return 属性值列表
-	 */
-	List<Boolean> getBoolList(String key);
-
-	/**
-	 * 获取Long型属性值列表
-	 *
-	 * @param key 属性名
-	 * @return 属性值列表
-	 */
-	List<Long> getLongList(String key);
-
-	/**
-	 * 获取Character型属性值列表
-	 *
-	 * @param key 属性名
-	 * @return 属性值列表
-	 */
-	List<Character> getCharList(String key);
-
-	/**
-	 * 获取Double型属性值列表
-	 *
-	 * @param key 属性名
-	 * @return 属性值列表
-	 */
-	List<Double> getDoubleList(String key);
-
-	/**
-	 * 获取Byte型属性值列表
-	 *
-	 * @param key 属性名
-	 * @return 属性值列表
-	 */
-	List<Byte> getByteList(String key);
-
-	/**
-	 * 获取BigDecimal型属性值列表
-	 *
-	 * @param key 属性名
-	 * @return 属性值列表
-	 */
-	List<BigDecimal> getBigDecimalList(String key);
-
-	/**
-	 * 获取BigInteger型属性值列表
-	 *
-	 * @param key 属性名
-	 * @return 属性值列表
-	 */
-	List<BigInteger> getBigIntegerList(String key);
-	/*-------------------------- List类型 end -------------------------------*/
-}

hutool-core/src/main/java/cn/hutool/core/lang/getter/OptArrayTypeGetter.java

@@ -1,117 +0,0 @@
-package cn.hutool.core.lang.getter;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-
-/**
- * 可选默认值的数组类型的Get接口
- * 提供一个统一的接口定义返回不同类型的值（基本类型）<br>
- * 如果值不存在或获取错误，返回默认值
- *
- * @author Looly
- * @since 4.0.2
- *
- */
-public interface OptArrayTypeGetter {
-	/*-------------------------- 数组类型 start -------------------------------*/
-
-	/**
-	 * 获取Object型属性值数组
-	 *
-	 * @param key 属性名
-	 * @param defaultValue 默认数组值
-	 * @return 属性值列表
-	 */
-	Object[] getObjs(String key, Object[] defaultValue);
-
-	/**
-	 * 获取String型属性值数组
-	 *
-	 * @param key 属性名
-	 * @param defaultValue 默认数组值
-	 * @return 属性值列表
-	 */
-	String[] getStrs(String key, String[] defaultValue);
-
-	/**
-	 * 获取Integer型属性值数组
-	 *
-	 * @param key 属性名
-	 * @param defaultValue 默认数组值
-	 * @return 属性值列表
-	 */
-	Integer[] getInts(String key, Integer[] defaultValue);
-
-	/**
-	 * 获取Short型属性值数组
-	 *
-	 * @param key 属性名
-	 * @param defaultValue 默认数组值
-	 * @return 属性值列表
-	 */
-	Short[] getShorts(String key, Short[] defaultValue);
-
-	/**
-	 * 获取Boolean型属性值数组
-	 *
-	 * @param key 属性名
-	 * @param defaultValue 默认数组值
-	 * @return 属性值列表
-	 */
-	Boolean[] getBools(String key, Boolean[] defaultValue);
-
-	/**
-	 * 获取Long型属性值数组
-	 *
-	 * @param key 属性名
-	 * @param defaultValue 默认数组值
-	 * @return 属性值列表
-	 */
-	Long[] getLongs(String key, Long[] defaultValue);
-
-	/**
-	 * 获取Character型属性值数组
-	 *
-	 * @param key 属性名
-	 * @param defaultValue 默认数组值
-	 * @return 属性值列表
-	 */
-	Character[] getChars(String key, Character[] defaultValue);
-
-	/**
-	 * 获取Double型属性值数组
-	 *
-	 * @param key 属性名
-	 * @param defaultValue 默认数组值
-	 * @return 属性值列表
-	 */
-	Double[] getDoubles(String key, Double[] defaultValue);
-
-	/**
-	 * 获取Byte型属性值数组
-	 *
-	 * @param key 属性名
-	 * @param defaultValue 默认数组值
-	 * @return 属性值列表
-	 */
-	Byte[] getBytes(String key, Byte[] defaultValue);
-
-	/**
-	 * 获取BigInteger型属性值数组
-	 *
-	 * @param key 属性名
-	 * @param defaultValue 默认数组值
-	 * @return 属性值列表
-	 */
-	BigInteger[] getBigIntegers(String key, BigInteger[] defaultValue);
-
-	/**
-	 * 获取BigDecimal型属性值数组
-	 *
-	 * @param key 属性名
-	 * @param defaultValue 默认数组值
-	 * @return 属性值列表
-	 */
-	BigDecimal[] getBigDecimals(String key, BigDecimal[] defaultValue);
-	/*-------------------------- 数组类型 end -------------------------------*/
-}

hutool-core/src/main/java/cn/hutool/core/lang/getter/OptBasicTypeGetter.java

@@ -1,153 +0,0 @@
-package cn.hutool.core.lang.getter;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.util.Date;
-
-/**
- * 可选默认值的基本类型的getter接口<br>
- * 提供一个统一的接口定义返回不同类型的值（基本类型）<br>
- * 如果值不存在或获取错误，返回默认值
- * @author Looly
- */
-public interface OptBasicTypeGetter<K> {
-	/*-------------------------- 基本类型 start -------------------------------*/
-
-	/**
-	 * 获取Object属性值
-	 * @param key 属性名
-	 * @param defaultValue 默认值
-	 * @return 属性值，无对应值返回defaultValue
-	 */
-	Object getObj(K key, Object defaultValue);
-
-	/**
-	 * 获取字符串型属性值<br>
-	 * 若获得的值为不可见字符，使用默认值
-	 *
-	 * @param key 属性名
-	 * @param defaultValue 默认值
-	 * @return 属性值，无对应值返回defaultValue
-	 */
-	String getStr(K key, String defaultValue);
-
-	/**
-	 * 获取int型属性值<br>
-	 * 若获得的值为不可见字符，使用默认值
-	 *
-	 * @param key 属性名
-	 * @param defaultValue 默认值
-	 * @return 属性值，无对应值返回defaultValue
-	 */
-	Integer getInt(K key, Integer defaultValue);
-
-	/**
-	 * 获取short型属性值<br>
-	 * 若获得的值为不可见字符，使用默认值
-	 *
-	 * @param key 属性名
-	 * @param defaultValue 默认值
-	 * @return 属性值，无对应值返回defaultValue
-	 */
-	Short getShort(K key, Short defaultValue);
-
-	/**
-	 * 获取boolean型属性值<br>
-	 * 若获得的值为不可见字符，使用默认值
-	 *
-	 * @param key 属性名
-	 * @param defaultValue 默认值
-	 * @return 属性值，无对应值返回defaultValue
-	 */
-	Boolean getBool(K key, Boolean defaultValue);
-
-	/**
-	 * 获取Long型属性值<br>
-	 * 若获得的值为不可见字符，使用默认值
-	 *
-	 * @param key 属性名
-	 * @param defaultValue 默认值
-	 * @return 属性值，无对应值返回defaultValue
-	 */
-	Long getLong(K key, Long defaultValue);
-
-	/**
-	 * 获取char型属性值<br>
-	 * 若获得的值为不可见字符，使用默认值
-	 *
-	 * @param key 属性名
-	 * @param defaultValue 默认值
-	 * @return 属性值，无对应值返回defaultValue
-	 */
-	Character getChar(K key, Character defaultValue);
-
-	/**
-	 * 获取float型属性值<br>
-	 * 若获得的值为不可见字符，使用默认值
-	 *
-	 * @param key 属性名
-	 * @param defaultValue 默认值
-	 * @return 属性值，无对应值返回defaultValue
-	 */
-	Float getFloat(K key, Float defaultValue);
-
-	/**
-	 * 获取double型属性值<br>
-	 * 若获得的值为不可见字符，使用默认值
-	 *
-	 * @param key 属性名
-	 * @param defaultValue 默认值
-	 * @return 属性值，无对应值返回defaultValue
-	 */
-	Double getDouble(K key, Double defaultValue);
-
-	/**
-	 * 获取byte型属性值<br>
-	 * 若获得的值为不可见字符，使用默认值
-	 *
-	 * @param key 属性名
-	 * @param defaultValue 默认值
-	 * @return 属性值，无对应值返回defaultValue
-	 */
-	Byte getByte(K key, Byte defaultValue);
-
-	/**
-	 * 获取BigDecimal型属性值<br>
-	 * 若获得的值为不可见字符，使用默认值
-	 *
-	 * @param key 属性名
-	 * @param defaultValue 默认值
-	 * @return 属性值，无对应值返回defaultValue
-	 */
-	BigDecimal getBigDecimal(K key, BigDecimal defaultValue);
-
-	/**
-	 * 获取BigInteger型属性值<br>
-	 * 若获得的值为不可见字符，使用默认值
-	 *
-	 * @param key 属性名
-	 * @param defaultValue 默认值
-	 * @return 属性值，无对应值返回defaultValue
-	 */
-	BigInteger getBigInteger(K key, BigInteger defaultValue);
-
-	/**
-	 * 获得Enum类型的值
-	 *
-	 * @param <E> 枚举类型
-	 * @param clazz Enum的Class
-	 * @param key KEY
-	 * @param defaultValue 默认值
-	 * @return Enum类型的值，无则返回Null
-	 */
-	<E extends Enum<E>> E getEnum(Class<E> clazz, K key, E defaultValue);
-
-	/**
-	 * 获取Date类型值
-	 * @param key 属性名
-	 * @param defaultValue 默认值
-	 * @return Date类型属性值
-	 */
-	Date getDate(K key, Date defaultValue);
-	/*-------------------------- 基本类型 end -------------------------------*/
-}

hutool-core/src/main/java/cn/hutool/core/lang/getter/OptNullBasicTypeFromObjectGetter.java

@@ -1,133 +0,0 @@
-package cn.hutool.core.lang.getter;
-
-import cn.hutool.core.convert.Convert;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.util.Date;
-
-/**
- * 基本类型的getter接口抽象实现，所有类型的值获取都是通过将getObj获得的值转换而来<br>
- * 用户只需实现getObj方法即可，其他类型将会从Object结果中转换
- * 在不提供默认值的情况下， 如果值不存在或获取错误，返回null<br>
- *
- * @author Looly
- */
-public interface OptNullBasicTypeFromObjectGetter<K> extends OptNullBasicTypeGetter<K> {
-	@Override
-	default String getStr(final K key, final String defaultValue) {
-		final Object obj = getObj(key);
-		if (null == obj) {
-			return defaultValue;
-		}
-		return Convert.toStr(obj, defaultValue);
-	}
-
-	@Override
-	default Integer getInt(final K key, final Integer defaultValue) {
-		final Object obj = getObj(key);
-		if (null == obj) {
-			return defaultValue;
-		}
-		return Convert.toInt(obj, defaultValue);
-	}
-
-	@Override
-	default Short getShort(final K key, final Short defaultValue) {
-		final Object obj = getObj(key);
-		if (null == obj) {
-			return defaultValue;
-		}
-		return Convert.toShort(obj, defaultValue);
-	}
-
-	@Override
-	default Boolean getBool(final K key, final Boolean defaultValue) {
-		final Object obj = getObj(key);
-		if (null == obj) {
-			return defaultValue;
-		}
-		return Convert.toBool(obj, defaultValue);
-	}
-
-	@Override
-	default Long getLong(final K key, final Long defaultValue) {
-		final Object obj = getObj(key);
-		if (null == obj) {
-			return defaultValue;
-		}
-		return Convert.toLong(obj, defaultValue);
-	}
-
-	@Override
-	default Character getChar(final K key, final Character defaultValue) {
-		final Object obj = getObj(key);
-		if (null == obj) {
-			return defaultValue;
-		}
-		return Convert.toChar(obj, defaultValue);
-	}
-
-	@Override
-	default Float getFloat(final K key, final Float defaultValue) {
-		final Object obj = getObj(key);
-		if (null == obj) {
-			return defaultValue;
-		}
-		return Convert.toFloat(obj, defaultValue);
-	}
-
-	@Override
-	default Double getDouble(final K key, final Double defaultValue) {
-		final Object obj = getObj(key);
-		if (null == obj) {
-			return defaultValue;
-		}
-		return Convert.toDouble(obj, defaultValue);
-	}
-
-	@Override
-	default Byte getByte(final K key, final Byte defaultValue) {
-		final Object obj = getObj(key);
-		if (null == obj) {
-			return defaultValue;
-		}
-		return Convert.toByte(obj, defaultValue);
-	}
-
-	@Override
-	default BigDecimal getBigDecimal(final K key, final BigDecimal defaultValue) {
-		final Object obj = getObj(key);
-		if (null == obj) {
-			return defaultValue;
-		}
-		return Convert.toBigDecimal(obj, defaultValue);
-	}
-
-	@Override
-	default BigInteger getBigInteger(final K key, final BigInteger defaultValue) {
-		final Object obj = getObj(key);
-		if (null == obj) {
-			return defaultValue;
-		}
-		return Convert.toBigInteger(obj, defaultValue);
-	}
-
-	@Override
-	default <E extends Enum<E>> E getEnum(final Class<E> clazz, final K key, final E defaultValue) {
-		final Object obj = getObj(key);
-		if (null == obj) {
-			return defaultValue;
-		}
-		return Convert.toEnum(clazz, obj, defaultValue);
-	}
-
-	@Override
-	default Date getDate(final K key, final Date defaultValue) {
-		final Object obj = getObj(key);
-		if (null == obj) {
-			return defaultValue;
-		}
-		return Convert.toDate(obj, defaultValue);
-	}
-}

hutool-core/src/main/java/cn/hutool/core/lang/getter/OptNullBasicTypeFromStringGetter.java

@@ -1,80 +0,0 @@
-package cn.hutool.core.lang.getter;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.util.Date;
-
-import cn.hutool.core.convert.Convert;
-
-/**
- * 基本类型的getter接口抽象实现，所有类型的值获取都是通过将String转换而来<br>
- * 用户只需实现getStr方法即可，其他类型将会从String结果中转换 在不提供默认值的情况下， 如果值不存在或获取错误，返回null<br>
- *
- * @author Looly
- */
-public interface OptNullBasicTypeFromStringGetter<K> extends OptNullBasicTypeGetter<K> {
-	@Override
-	default Object getObj(final K key, final Object defaultValue) {
-		return getStr(key, null == defaultValue ? null : defaultValue.toString());
-	}
-
-	@Override
-	default Integer getInt(final K key, final Integer defaultValue) {
-		return Convert.toInt(getStr(key), defaultValue);
-	}
-
-	@Override
-	default Short getShort(final K key, final Short defaultValue) {
-		return Convert.toShort(getStr(key), defaultValue);
-	}
-
-	@Override
-	default Boolean getBool(final K key, final Boolean defaultValue) {
-		return Convert.toBool(getStr(key), defaultValue);
-	}
-
-	@Override
-	default Long getLong(final K key, final Long defaultValue) {
-		return Convert.toLong(getStr(key), defaultValue);
-	}
-
-	@Override
-	default Character getChar(final K key, final Character defaultValue) {
-		return Convert.toChar(getStr(key), defaultValue);
-	}
-
-	@Override
-	default Float getFloat(final K key, final Float defaultValue) {
-		return Convert.toFloat(getStr(key), defaultValue);
-	}
-
-	@Override
-	default Double getDouble(final K key, final Double defaultValue) {
-		return Convert.toDouble(getStr(key), defaultValue);
-	}
-
-	@Override
-	default Byte getByte(final K key, final Byte defaultValue) {
-		return Convert.toByte(getStr(key), defaultValue);
-	}
-
-	@Override
-	default BigDecimal getBigDecimal(final K key, final BigDecimal defaultValue) {
-		return Convert.toBigDecimal(getStr(key), defaultValue);
-	}
-
-	@Override
-	default BigInteger getBigInteger(final K key, final BigInteger defaultValue) {
-		return Convert.toBigInteger(getStr(key), defaultValue);
-	}
-
-	@Override
-	default <E extends Enum<E>> E getEnum(final Class<E> clazz, final K key, final E defaultValue) {
-		return Convert.toEnum(clazz, getStr(key), defaultValue);
-	}
-
-	@Override
-	default Date getDate(final K key, final Date defaultValue) {
-		return Convert.toDate(getStr(key), defaultValue);
-	}
-}

hutool-core/src/main/java/cn/hutool/core/lang/getter/OptNullBasicTypeGetter.java

@@ -1,176 +0,0 @@
-package cn.hutool.core.lang.getter;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.util.Date;
-
-/**
- * 基本类型的getter接口抽象实现<br>
- * 提供一个统一的接口定义返回不同类型的值（基本类型）<br>
- * 在不提供默认值的情况下， 如果值不存在或获取错误，返回null<br>
- * 用户只需实现{@link OptBasicTypeGetter}接口即可
- * @author Looly
- */
-public interface OptNullBasicTypeGetter<K> extends BasicTypeGetter<K>, OptBasicTypeGetter<K>{
-	@Override
-	default Object getObj(final K key) {
-		return getObj(key, null);
-	}
-
-	/**
-	 * 获取字符串型属性值<br>
-	 * 无值或获取错误返回null
-	 *
-	 * @param key 属性名
-	 * @return 属性值
-	 */
-	@Override
-	default String getStr(final K key){
-		return this.getStr(key, null);
-	}
-
-	/**
-	 * 获取int型属性值<br>
-	 * 无值或获取错误返回null
-	 *
-	 * @param key 属性名
-	 * @return 属性值
-	 */
-	@Override
-	default Integer getInt(final K key) {
-		return this.getInt(key, null);
-	}
-
-	/**
-	 * 获取short型属性值<br>
-	 * 无值或获取错误返回null
-	 *
-	 * @param key 属性名
-	 * @return 属性值
-	 */
-	@Override
-	default Short getShort(final K key){
-		return this.getShort(key, null);
-	}
-
-	/**
-	 * 获取boolean型属性值<br>
-	 * 无值或获取错误返回null
-	 *
-	 * @param key 属性名
-	 * @return 属性值
-	 */
-	@Override
-	default Boolean getBool(final K key){
-		return this.getBool(key, null);
-	}
-
-	/**
-	 * 获取long型属性值<br>
-	 * 无值或获取错误返回null
-	 *
-	 * @param key 属性名
-	 * @return 属性值
-	 */
-	@Override
-	default Long getLong(final K key){
-		return this.getLong(key, null);
-	}
-
-	/**
-	 * 获取char型属性值<br>
-	 * 无值或获取错误返回null
-	 *
-	 * @param key 属性名
-	 * @return 属性值
-	 */
-	@Override
-	default Character getChar(final K key){
-		return this.getChar(key, null);
-	}
-
-	/**
-	 * 获取float型属性值<br>
-	 * 无值或获取错误返回null
-	 *
-	 * @param key 属性名
-	 * @return 属性值
-	 */
-	@Override
-	default Float getFloat(final K key){
-		return this.getFloat(key, null);
-	}
-
-	/**
-	 * 获取double型属性值<br>
-	 * 无值或获取错误返回null
-	 *
-	 * @param key 属性名
-	 * @return 属性值
-	 */
-	@Override
-	default Double getDouble(final K key){
-		return this.getDouble(key, null);
-	}
-
-	/**
-	 * 获取byte型属性值<br>
-	 * 无值或获取错误返回null
-	 *
-	 * @param key 属性名
-	 * @return 属性值
-	 */
-	@Override
-	default Byte getByte(final K key){
-		return this.getByte(key, null);
-	}
-
-	/**
-	 * 获取BigDecimal型属性值<br>
-	 * 无值或获取错误返回null
-	 *
-	 * @param key 属性名
-	 * @return 属性值
-	 */
-	@Override
-	default BigDecimal getBigDecimal(final K key){
-		return this.getBigDecimal(key, null);
-	}
-
-	/**
-	 * 获取BigInteger型属性值<br>
-	 * 无值或获取错误返回null
-	 *
-	 * @param key 属性名
-	 * @return 属性值
-	 */
-	@Override
-	default BigInteger getBigInteger(final K key){
-		return this.getBigInteger(key, null);
-	}
-
-	/**
-	 * 获取Enum型属性值<br>
-	 * 无值或获取错误返回null
-	 *
-	 * @param clazz Enum 的 Class
-	 * @param key 属性名
-	 * @return 属性值
-	 */
-	@Override
-	default <E extends Enum<E>> E getEnum(final Class<E> clazz, final K key) {
-		return this.getEnum(clazz, key, null);
-	}
-
-	/**
-	 * 获取Date型属性值<br>
-	 * 无值或获取错误返回null
-	 *
-	 * @param key 属性名
-	 * @return 属性值
-	 */
-	@Override
-	default Date getDate(final K key) {
-		return this.getDate(key, null);
-	}
-}

hutool-core/src/main/java/cn/hutool/core/lang/getter/TypeGetter.java

@@ -0,0 +1,529 @@
+package cn.hutool.core.lang.getter;
+
+import cn.hutool.core.convert.Convert;
+
+import java.lang.reflect.Type;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.util.Date;
+
+/**
+ * 基本类型的getter接口<br>
+ * 提供一个统一的接口定义返回不同类型的值（基本类型），定义类型包括：
+ * <ul>
+ *     <li>Object</li>
+ *     <li>String</li>
+ *     <li>Integer</li>
+ *     <li>Short</li>
+ *     <li>Boolean</li>
+ *     <li>Long</li>
+ *     <li>Character</li>
+ *     <li>Float</li>
+ *     <li>Double</li>
+ *     <li>Byte</li>
+ *     <li>BigDecimal</li>
+ *     <li>BigInteger</li>
+ *     <li>Enum</li>
+ *     <li>Number</li>
+ *     <li>Date</li>
+ *     <li>java.sql.Time</li>
+ *     <li>java.sql.Timestamp</li>
+ *     <li>java.sql.Timestamp</li>
+ *     <li>LocalDateTime</li>
+ *     <li>LocalDate</li>
+ *     <li>LocalTime</li>
+ * </ul>
+ * 通过实现此接口，最简单方式为通过实现{@link #getObj(Object, Object)}方法，完成所有类型的值获取，获取默认采用
+ * {@link Convert}方式自动转换。如果有自定义实现，重写对应getXXX方法即可。
+ *
+ * @param <K> 键类型
+ * @author Looly
+ * @since 6.0.0
+ */
+public interface TypeGetter<K> {
+	/*-------------------------- 基本类型 start -------------------------------*/
+
+	/**
+	 * 获取Object属性值
+	 *
+	 * @param key          属性名
+	 * @param defaultValue 默认值
+	 * @return 属性值，无对应值返回defaultValue
+	 */
+	Object getObj(K key, Object defaultValue);
+
+	/**
+	 * 获取Object属性值，最原始的对象获取，没有任何转换或类型判断
+	 *
+	 * @param key 属性名
+	 * @return 属性值
+	 */
+	default Object getObj(final K key) {
+		return getObj(key, null);
+	}
+
+	/**
+	 * 获取指定类型的值，默认自动转换值类型
+	 *
+	 * @param <T>          目标类型
+	 * @param key          键
+	 * @param type         目标类型
+	 * @return 结果值
+	 */
+	default <T> T get(final K key, final Type type) {
+		return get(key, type, null);
+	}
+
+	/**
+	 * 获取指定类型的值，默认自动转换值类型
+	 *
+	 * @param <T>          目标类型
+	 * @param key          键
+	 * @param type         目标类型
+	 * @param defaultValue 默认值
+	 * @return 结果值
+	 */
+	default <T> T get(final K key, final Type type, final T defaultValue) {
+		return Convert.convert(type, getObj(key), defaultValue);
+	}
+
+	/**
+	 * 获取字符串型属性值<br>
+	 * 若获得的值为不可见字符，使用默认值
+	 *
+	 * @param key          属性名
+	 * @param defaultValue 默认值
+	 * @return 属性值，无对应值返回defaultValue
+	 */
+	default String getStr(final K key, final String defaultValue) {
+		return get(key, String.class, defaultValue);
+	}
+
+	/**
+	 * 获取字符串型属性值
+	 *
+	 * @param key 属性名
+	 * @return 属性值
+	 */
+	default String getStr(final K key) {
+		return getStr(key, null);
+	}
+
+	/**
+	 * 获取int型属性值<br>
+	 * 若获得的值为不可见字符，使用默认值
+	 *
+	 * @param key          属性名
+	 * @param defaultValue 默认值
+	 * @return 属性值，无对应值返回defaultValue
+	 */
+	default Integer getInt(final K key, final Integer defaultValue) {
+		return get(key, Integer.class, defaultValue);
+	}
+
+	/**
+	 * 获取int型属性值
+	 *
+	 * @param key 属性名
+	 * @return 属性值
+	 */
+	default Integer getInt(final K key) {
+		return getInt(key, null);
+	}
+
+	/**
+	 * 获取short型属性值<br>
+	 * 若获得的值为不可见字符，使用默认值
+	 *
+	 * @param key          属性名
+	 * @param defaultValue 默认值
+	 * @return 属性值，无对应值返回defaultValue
+	 */
+	default Short getShort(final K key, final Short defaultValue) {
+		return get(key, Short.class, defaultValue);
+	}
+
+	/**
+	 * 获取short型属性值
+	 *
+	 * @param key 属性名
+	 * @return 属性值
+	 */
+	default Short getShort(final K key) {
+		return getShort(key, null);
+	}
+
+	/**
+	 * 获取boolean型属性值<br>
+	 * 若获得的值为不可见字符，使用默认值
+	 *
+	 * @param key          属性名
+	 * @param defaultValue 默认值
+	 * @return 属性值，无对应值返回defaultValue
+	 */
+	default Boolean getBool(final K key, final Boolean defaultValue) {
+		return get(key, Boolean.class, defaultValue);
+	}
+
+	/**
+	 * 获取boolean型属性值
+	 *
+	 * @param key 属性名
+	 * @return 属性值
+	 */
+	default Boolean getBool(final K key) {
+		return getBool(key, null);
+	}
+
+	/**
+	 * 获取Long型属性值<br>
+	 * 若获得的值为不可见字符，使用默认值
+	 *
+	 * @param key          属性名
+	 * @param defaultValue 默认值
+	 * @return 属性值，无对应值返回defaultValue
+	 */
+	default Long getLong(final K key, final Long defaultValue) {
+		return get(key, Long.class, defaultValue);
+	}
+
+	/**
+	 * 获取long型属性值
+	 *
+	 * @param key 属性名
+	 * @return 属性值
+	 */
+	default Long getLong(final K key) {
+		return getLong(key, null);
+	}
+
+	/**
+	 * 获取char型属性值<br>
+	 * 若获得的值为不可见字符，使用默认值
+	 *
+	 * @param key          属性名
+	 * @param defaultValue 默认值
+	 * @return 属性值，无对应值返回defaultValue
+	 */
+	default Character getChar(final K key, final Character defaultValue) {
+		return get(key, Character.class, defaultValue);
+	}
+
+	/**
+	 * 获取char型属性值
+	 *
+	 * @param key 属性名
+	 * @return 属性值
+	 */
+	default Character getChar(final K key) {
+		return getChar(key, null);
+	}
+
+	/**
+	 * 获取float型属性值<br>
+	 * 若获得的值为不可见字符，使用默认值
+	 *
+	 * @param key          属性名
+	 * @param defaultValue 默认值
+	 * @return 属性值，无对应值返回defaultValue
+	 */
+	default Float getFloat(final K key, final Float defaultValue) {
+		return get(key, Float.class, defaultValue);
+	}
+
+	/**
+	 * 获取float型属性值<br>
+	 *
+	 * @param key 属性名
+	 * @return 属性值
+	 */
+	default Float getFloat(final K key) {
+		return getFloat(key, null);
+	}
+
+	/**
+	 * 获取double型属性值<br>
+	 * 若获得的值为不可见字符，使用默认值
+	 *
+	 * @param key          属性名
+	 * @param defaultValue 默认值
+	 * @return 属性值，无对应值返回defaultValue
+	 */
+	default Double getDouble(final K key, final Double defaultValue) {
+		return get(key, Double.class, defaultValue);
+	}
+
+	/**
+	 * 获取double型属性值
+	 *
+	 * @param key 属性名
+	 * @return 属性值
+	 */
+	default Double getDouble(final K key) {
+		return getDouble(key, null);
+	}
+
+	/**
+	 * 获取byte型属性值
+	 *
+	 * @param key          属性名
+	 * @param defaultValue 默认值
+	 * @return 属性值，无对应值返回defaultValue
+	 */
+	default Byte getByte(final K key, final Byte defaultValue) {
+		return get(key, Byte.class, defaultValue);
+	}
+
+	/**
+	 * 获取byte型属性值
+	 *
+	 * @param key 属性名
+	 * @return 属性值
+	 */
+	default Byte getByte(final K key) {
+		return getByte(key, null);
+	}
+
+	/**
+	 * 获取bytes型属性值
+	 *
+	 * @param key          属性名
+	 * @param defaultValue 默认值
+	 * @return 属性值，无对应值返回defaultValue
+	 */
+	default byte[] getBytes(final K key, final byte[] defaultValue) {
+		return get(key, byte[].class, defaultValue);
+	}
+
+	/**
+	 * 获取bytes型属性值
+	 *
+	 * @param key 属性名
+	 * @return 属性值
+	 */
+	default byte[] getBytes(final K key) {
+		return getBytes(key, null);
+	}
+
+	/**
+	 * 获取BigDecimal型属性值<br>
+	 * 若获得的值为不可见字符，使用默认值
+	 *
+	 * @param key          属性名
+	 * @param defaultValue 默认值
+	 * @return 属性值，无对应值返回defaultValue
+	 */
+	default BigDecimal getBigDecimal(final K key, final BigDecimal defaultValue) {
+		return get(key, BigDecimal.class, defaultValue);
+	}
+
+	/**
+	 * 获取BigDecimal型属性值
+	 *
+	 * @param key 属性名
+	 * @return 属性值
+	 */
+	default BigDecimal getBigDecimal(final K key) {
+		return getBigDecimal(key, null);
+	}
+
+	/**
+	 * 获取BigInteger型属性值<br>
+	 * 若获得的值为不可见字符，使用默认值
+	 *
+	 * @param key          属性名
+	 * @param defaultValue 默认值
+	 * @return 属性值，无对应值返回defaultValue
+	 */
+	default BigInteger getBigInteger(final K key, final BigInteger defaultValue) {
+		return get(key, BigInteger.class, defaultValue);
+	}
+
+	/**
+	 * 获取BigInteger型属性值
+	 *
+	 * @param key 属性名
+	 * @return 属性值
+	 */
+	default BigInteger getBigInteger(final K key) {
+		return getBigInteger(key, null);
+	}
+
+	/**
+	 * 获得Enum类型的值
+	 *
+	 * @param <E>          枚举类型
+	 * @param clazz        Enum的Class
+	 * @param key          KEY
+	 * @param defaultValue 默认值
+	 * @return Enum类型的值，无则返回Null
+	 */
+	default <E extends Enum<E>> E getEnum(final Class<E> clazz, final K key, final E defaultValue) {
+		return get(key, clazz, defaultValue);
+	}
+
+	/**
+	 * 获得Enum类型的值
+	 *
+	 * @param <E>   枚举类型
+	 * @param clazz Enum的Class
+	 * @param key   KEY
+	 * @return Enum类型的值，无则返回Null
+	 */
+	default <E extends Enum<E>> E getEnum(final Class<E> clazz, final K key) {
+		return getEnum(clazz, key, null);
+	}
+
+	/**
+	 * 获取Number类型值
+	 *
+	 * @param key          属性名
+	 * @param defaultValue 默认值
+	 * @return Number类型属性值
+	 */
+	default Number getNumber(final K key, final Number defaultValue) {
+		return get(key, Number.class, defaultValue);
+	}
+
+	/**
+	 * 获取Number类型值
+	 *
+	 * @param key 属性名
+	 * @return Number类型属性值
+	 */
+	default Number getNumber(final K key) {
+		return getNumber(key, null);
+	}
+
+	/**
+	 * 获取Date类型值
+	 *
+	 * @param key          属性名
+	 * @param defaultValue 默认值
+	 * @return Date类型属性值
+	 */
+	default Date getDate(final K key, final Date defaultValue) {
+		return get(key, Date.class, defaultValue);
+	}
+
+	/**
+	 * 获取Date类型值
+	 *
+	 * @param key 属性名
+	 * @return Date类型属性值
+	 */
+	default Date getDate(final K key) {
+		return getDate(key, null);
+	}
+
+	/**
+	 * 获取LocalTime类型值
+	 *
+	 * @param key          属性名
+	 * @param defaultValue 默认值
+	 * @return LocalTime类型属性值
+	 */
+	default Time getSqlTime(final K key, final Time defaultValue) {
+		return get(key, Time.class, defaultValue);
+	}
+
+	/**
+	 * 获取Time类型值
+	 *
+	 * @param key 属性名
+	 * @return Time类型属性值
+	 */
+	default Time getSqlTime(final K key) {
+		return getSqlTime(key, null);
+	}
+
+	/**
+	 * 获取Timestamp类型值
+	 *
+	 * @param key          属性名
+	 * @param defaultValue 默认值
+	 * @return Timestamp类型属性值
+	 */
+	default Timestamp getSqlTimestamp(final K key, final Timestamp defaultValue) {
+		return get(key, Timestamp.class, defaultValue);
+	}
+
+	/**
+	 * 获取Timestamp类型值
+	 *
+	 * @param key 属性名
+	 * @return Timestamp类型属性值
+	 */
+	default Timestamp getSqlTimestamp(final K key) {
+		return getSqlTimestamp(key, null);
+	}
+
+	/**
+	 * 获取LocalDateTime类型值
+	 *
+	 * @param key          属性名
+	 * @param defaultValue 默认值
+	 * @return LocalDateTime类型属性值
+	 */
+	default LocalDateTime getLocalDateTime(final K key, final LocalDateTime defaultValue) {
+		return get(key, LocalDateTime.class, defaultValue);
+	}
+
+	/**
+	 * 获取LocalDateTime类型值
+	 *
+	 * @param key 属性名
+	 * @return LocalDateTime类型属性值
+	 */
+	default LocalDateTime getLocalDateTime(final K key) {
+		return getLocalDateTime(key, null);
+	}
+
+	/**
+	 * 获取LocalDate类型值
+	 *
+	 * @param key          属性名
+	 * @param defaultValue 默认值
+	 * @return LocalTime类型属性值
+	 */
+	default LocalDate getLocalDate(final K key, final LocalDate defaultValue) {
+		return get(key, LocalDate.class, defaultValue);
+	}
+
+	/**
+	 * 获取LocalDate类型值
+	 *
+	 * @param key 属性名
+	 * @return LocalTime类型属性值
+	 */
+	default LocalDate getLocalDate(final K key) {
+		return getLocalDate(key, null);
+	}
+
+	/**
+	 * 获取LocalTime类型值
+	 *
+	 * @param key          属性名
+	 * @param defaultValue 默认值
+	 * @return LocalTime类型属性值
+	 */
+	default LocalTime getLocalTime(final K key, final LocalTime defaultValue) {
+		return get(key, LocalTime.class, defaultValue);
+	}
+
+	/**
+	 * 获取LocalTime类型值
+	 *
+	 * @param key 属性名
+	 * @return LocalTime类型属性值
+	 */
+	default LocalTime getLocalTime(final K key) {
+		return getLocalTime(key, null);
+	}
+	/*-------------------------- 基本类型 end -------------------------------*/
+}

hutool-core/src/main/java/cn/hutool/core/map/Dict.java

@@ -9,15 +9,10 @@ import cn.hutool.core.exceptions.CloneRuntimeException;
 import cn.hutool.core.lang.Assert;
 import cn.hutool.core.lang.func.LambdaUtil;
 import cn.hutool.core.lang.func.SerSupplier;
-import cn.hutool.core.lang.getter.BasicTypeGetter;
+import cn.hutool.core.lang.getter.TypeGetter;
 
 import java.lang.reflect.Type;
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.sql.Time;
-import java.sql.Timestamp;
 import java.util.Arrays;
-import java.util.Date;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
@@ -29,7 +24,7 @@ import java.util.Objects;
  *
  * @author looly
  */
-public class Dict extends CustomKeyMap<String, Object> implements BasicTypeGetter<String> {
+public class Dict extends CustomKeyMap<String, Object> implements TypeGetter<String> {
 	private static final long serialVersionUID = 6135423866861206530L;
 
 	static final float DEFAULT_LOAD_FACTOR = 0.75f;
@@ -352,10 +347,9 @@ public class Dict extends CustomKeyMap<String, Object> implements BasicTypeGette
 	// -------------------------------------------------------------------- Set end
 
 	// -------------------------------------------------------------------- Get start
-
 	@Override
-	public Object getObj(final String key) {
-		return super.get(key);
+	public Object getObj(final String key, final Object defaultValue) {
+		return getOrDefault(key, defaultValue);
 	}
 
 	/**
@@ -366,151 +360,9 @@ public class Dict extends CustomKeyMap<String, Object> implements BasicTypeGette
 	 * @return 字段值
 	 * @since 4.6.3
 	 */
-	public <T> T getBean(final String attr) {
-		return get(attr, null);
-	}
-
-	/**
-	 * 获得特定类型值
-	 *
-	 * @param <T>          值类型
-	 * @param attr         字段名
-	 * @param defaultValue 默认值
-	 * @return 字段值
-	 */
 	@SuppressWarnings("unchecked")
-	public <T> T get(final String attr, final T defaultValue) {
-		final Object result = get(attr);
-		return (T) (result != null ? result : defaultValue);
-	}
-
-	/**
-	 * @param attr 字段名
-	 * @return 字段值
-	 */
-	@Override
-	public String getStr(final String attr) {
-		return Convert.toStr(get(attr), null);
-	}
-
-	/**
-	 * @param attr 字段名
-	 * @return 字段值
-	 */
-	@Override
-	public Integer getInt(final String attr) {
-		return Convert.toInt(get(attr), null);
-	}
-
-	/**
-	 * @param attr 字段名
-	 * @return 字段值
-	 */
-	@Override
-	public Long getLong(final String attr) {
-		return Convert.toLong(get(attr), null);
-	}
-
-	/**
-	 * @param attr 字段名
-	 * @return 字段值
-	 */
-	@Override
-	public Float getFloat(final String attr) {
-		return Convert.toFloat(get(attr), null);
-	}
-
-	@Override
-	public Short getShort(final String attr) {
-		return Convert.toShort(get(attr), null);
-	}
-
-	@Override
-	public Character getChar(final String attr) {
-		return Convert.toChar(get(attr), null);
-	}
-
-	@Override
-	public Double getDouble(final String attr) {
-		return Convert.toDouble(get(attr), null);
-	}
-
-	@Override
-	public Byte getByte(final String attr) {
-		return Convert.toByte(get(attr), null);
-	}
-
-	/**
-	 * @param attr 字段名
-	 * @return 字段值
-	 */
-	@Override
-	public Boolean getBool(final String attr) {
-		return Convert.toBool(get(attr), null);
-	}
-
-	/**
-	 * @param attr 字段名
-	 * @return 字段值
-	 */
-	@Override
-	public BigDecimal getBigDecimal(final String attr) {
-		return Convert.toBigDecimal(get(attr));
-	}
-
-	/**
-	 * @param attr 字段名
-	 * @return 字段值
-	 */
-	@Override
-	public BigInteger getBigInteger(final String attr) {
-		return Convert.toBigInteger(get(attr));
-	}
-
-	@Override
-	public <E extends Enum<E>> E getEnum(final Class<E> clazz, final String key) {
-		return Convert.toEnum(clazz, get(key));
-	}
-
-	/**
-	 * @param attr 字段名
-	 * @return 字段值
-	 */
-	public byte[] getBytes(final String attr) {
-		return get(attr, null);
-	}
-
-	/**
-	 * @param attr 字段名
-	 * @return 字段值
-	 */
-	@Override
-	public Date getDate(final String attr) {
-		return get(attr, null);
-	}
-
-	/**
-	 * @param attr 字段名
-	 * @return 字段值
-	 */
-	public Time getTime(final String attr) {
-		return get(attr, null);
-	}
-
-	/**
-	 * @param attr 字段名
-	 * @return 字段值
-	 */
-	public Timestamp getTimestamp(final String attr) {
-		return get(attr, null);
-	}
-
-	/**
-	 * @param attr 字段名
-	 * @return 字段值
-	 */
-	public Number getNumber(final String attr) {
-		return get(attr, null);
+	public <T> T getBean(final String attr) {
+		return (T) get(attr);
 	}
 
 	/**

hutool-core/src/main/java/cn/hutool/core/map/MapProxy.java

@@ -1,11 +1,11 @@
 package cn.hutool.core.map;
 
+import cn.hutool.core.classloader.ClassLoaderUtil;
 import cn.hutool.core.convert.Convert;
-import cn.hutool.core.lang.getter.OptNullBasicTypeFromObjectGetter;
+import cn.hutool.core.lang.getter.TypeGetter;
+import cn.hutool.core.text.StrUtil;
 import cn.hutool.core.util.ArrayUtil;
 import cn.hutool.core.util.BooleanUtil;
-import cn.hutool.core.classloader.ClassLoaderUtil;
-import cn.hutool.core.text.StrUtil;
 
 import java.io.Serializable;
 import java.lang.reflect.InvocationHandler;
@@ -21,7 +21,7 @@ import java.util.Set;
  * @author looly
  * @since 3.2.0
  */
-public class MapProxy implements Map<Object, Object>, OptNullBasicTypeFromObjectGetter<Object>, InvocationHandler, Serializable {
+public class MapProxy implements Map<Object, Object>, TypeGetter<Object>, InvocationHandler, Serializable {
 	private static final long serialVersionUID = 1L;
 
 	@SuppressWarnings("rawtypes")
@@ -32,7 +32,7 @@ public class MapProxy implements Map<Object, Object>, OptNullBasicTypeFromObject
 	 * 此类对Map做一次包装，提供各种getXXX方法
 	 *
 	 * @param map 被代理的Map
-	 * @return {@link MapProxy}
+	 * @return {@code MapProxy}
 	 */
 	public static MapProxy of(final Map<?, ?> map) {
 		return (map instanceof MapProxy) ? (MapProxy) map : new MapProxy(map);
@@ -47,10 +47,10 @@ public class MapProxy implements Map<Object, Object>, OptNullBasicTypeFromObject
 		this.map = map;
 	}
 
+	@SuppressWarnings("unchecked")
 	@Override
 	public Object getObj(final Object key, final Object defaultValue) {
-		final Object value = map.get(key);
-		return null != value ? value : defaultValue;
+		return map.getOrDefault(key, defaultValue);
 	}
 
 	@Override

hutool-core/src/main/java/cn/hutool/core/map/multi/ListValueMap.java

@@ -22,7 +22,7 @@ public class ListValueMap<K, V> extends AbsCollValueMap<K, V> {
 	 *
 	 * @param mapFactory 创建集合的工厂反方
 	 */
-	public ListValueMap(Supplier<Map<K, Collection<V>>> mapFactory) {
+	public ListValueMap(final Supplier<Map<K, Collection<V>>> mapFactory) {
 		super(mapFactory);
 	}
 
@@ -31,7 +31,7 @@ public class ListValueMap<K, V> extends AbsCollValueMap<K, V> {
 	 *
 	 * @param map 提供数据的原始集合
 	 */
-	public ListValueMap(Map<K, Collection<V>> map) {
+	public ListValueMap(final Map<K, Collection<V>> map) {
 		super(map);
 	}
 

hutool-core/src/main/java/cn/hutool/core/text/CharSequenceUtil.java

@@ -3420,7 +3420,6 @@ public class CharSequenceUtil extends StrChecker {
 	/**
 	 * 替换所有正则匹配的文本，并使用自定义函数决定如何替换<br>
 	 * replaceFun可以提取出匹配到的内容的不同部分，然后经过重新处理、组装变成新的内容放回原位。
-	 *
 	 * <pre class="code">
 	 *     replace(this.content, "(\\d+)", parameters -&gt; "-" + parameters.group(1) + "-")
 	 *     // 结果为："ZZZaaabbbccc中文-1234-"

hutool-core/src/test/java/cn/hutool/core/collection/MapProxyTest.java

@@ -1,15 +1,14 @@
 package cn.hutool.core.collection;
 
+import cn.hutool.core.map.MapProxy;
+import org.junit.Assert;
+import org.junit.Test;
+
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
 
-import org.junit.Assert;
-import org.junit.Test;
-
-import cn.hutool.core.map.MapProxy;
-
 public class MapProxyTest {
 
 	@Test
@@ -26,6 +25,7 @@ public class MapProxyTest {
 		Assert.assertFalse(keys.isEmpty());
 
 		final Set<Entry<Object,Object>> entrys = mapProxy.entrySet();
+		//noinspection ConstantConditions
 		Assert.assertFalse(entrys.isEmpty());
 	}
 

hutool-core/src/test/java/cn/hutool/core/convert/ConvertTest.java

@@ -360,6 +360,8 @@ public class ConvertTest {
 		final String str = "33020000210909112800000124";
 		final BigDecimal bigDecimal = Convert.toBigDecimal(str);
 		Assert.assertEquals(str, bigDecimal.toPlainString());
+
+		Assert.assertNull(Convert.toBigDecimal("  "));
 	}
 
 	@Test

hutool-core/src/test/java/cn/hutool/core/stream/AbstractEnhancedWrappedStreamTest.java

@@ -62,11 +62,15 @@ public class AbstractEnhancedWrappedStreamTest {
 	public void testToMap() {
 		final List<Integer> list = asList(1, 2, 3);
 		final Map<String, Integer> identityMap = wrap(list).toMap(String::valueOf);
-		Assert.assertEquals(new HashMap<String, Integer>() {{
-			put("1", 1);
-			put("2", 2);
-			put("3", 3);
-		}}, identityMap);
+		Assert.assertEquals(new HashMap<String, Integer>() {
+			private static final long serialVersionUID = 1L;
+
+			{
+				put("1", 1);
+				put("2", 2);
+				put("3", 3);
+			}
+		}, identityMap);
 	}
 
 	@Test
@@ -82,11 +86,15 @@ public class AbstractEnhancedWrappedStreamTest {
 		final List<Integer> orders = asList(1, 2, 3);
 		final List<String> list = asList("dromara", "hutool", "sweet");
 		final Map<Integer, String> toZip = wrap(orders).toZip(list);
-		Assert.assertEquals(new HashMap<Integer, String>() {{
-			put(1, "dromara");
-			put(2, "hutool");
-			put(3, "sweet");
-		}}, toZip);
+		Assert.assertEquals(new HashMap<Integer, String>() {
+			private static final long serialVersionUID = 1L;
+
+			{
+				put(1, "dromara");
+				put(2, "hutool");
+				put(3, "sweet");
+			}
+		}, toZip);
 	}
 
 	@Test
@@ -150,11 +158,15 @@ public class AbstractEnhancedWrappedStreamTest {
 	@Test
 	public void testGrouping() {
 		final List<Integer> list = asList(1, 2, 3);
-		final Map<String, List<Integer>> map = new HashMap<String, List<Integer>>() {{
-			put("1", singletonList(1));
-			put("2", singletonList(2));
-			put("3", singletonList(3));
-		}};
+		final Map<String, List<Integer>> map = new HashMap<String, List<Integer>>() {
+			private static final long serialVersionUID = 1L;
+
+			{
+				put("1", singletonList(1));
+				put("2", singletonList(2));
+				put("3", singletonList(3));
+			}
+		};
 
 		Map<String, List<Integer>> group = wrap(list).group(String::valueOf, HashMap::new, Collectors.toList());
 		Assert.assertEquals(map, group);
@@ -167,10 +179,13 @@ public class AbstractEnhancedWrappedStreamTest {
 	@Test
 	public void testPartitioning() {
 		final List<Integer> list = asList(1, 2, 3);
-		final Map<Boolean, List<Integer>> map = new HashMap<Boolean, List<Integer>>() {{
-			put(Boolean.TRUE, singletonList(2));
-			put(Boolean.FALSE, asList(1, 3));
-		}};
+		final Map<Boolean, List<Integer>> map = new HashMap<Boolean, List<Integer>>() {
+			private static final long serialVersionUID = 1L;
+			{
+				put(Boolean.TRUE, singletonList(2));
+				put(Boolean.FALSE, asList(1, 3));
+			}
+		};
 
 		Map<Boolean, List<Integer>> partition = wrap(list).partition(t -> (t & 1) == 0, Collectors.toList());
 		Assert.assertEquals(map, partition);
@@ -553,7 +568,7 @@ public class AbstractEnhancedWrappedStreamTest {
 
 	@Test
 	public void testFlatTree() {
-		final Tree root = new Tree(1, asList(new Tree(2, asList(new Tree(3, Collections.emptyList())))));
+		final Tree root = new Tree(1, ListUtil.of(new Tree(2, ListUtil.of(new Tree(3, Collections.emptyList())))));
 		Assert.assertEquals(3L, wrap(root).flatTree(Tree::getChildren, Tree::setChildren).count());
 	}
 
@@ -567,7 +582,7 @@ public class AbstractEnhancedWrappedStreamTest {
 	@Test
 	public void testMapNonNull() {
 		Assert.assertEquals(
-				asList("3"), wrap(null, 2, 3, 4).mapNonNull(t -> ((t & 1) == 0) ? null : String.valueOf(t)).toList()
+				ListUtil.of("3"), wrap(null, 2, 3, 4).mapNonNull(t -> ((t & 1) == 0) ? null : String.valueOf(t)).toList()
 		);
 	}
 
@@ -636,7 +651,7 @@ public class AbstractEnhancedWrappedStreamTest {
 		List<String> zip = wrap(orders).zip(list, (e1, e2) -> e1 + "." + e2).toList();
 		Assert.assertEquals(Arrays.asList("1.dromara", "2.hutool", "3.sweet"), zip);
 
-		zip = this.wrap((Stream<Integer>)EasyStream.iterate(1, i -> i + 1)).limit(10).zip(list, (e1, e2) -> e1 + "." + e2).toList();
+		zip = this.wrap((Stream<Integer>) EasyStream.iterate(1, i -> i + 1)).limit(10).zip(list, (e1, e2) -> e1 + "." + e2).toList();
 		Assert.assertEquals(Arrays.asList("1.dromara", "2.hutool", "3.sweet"), zip);
 	}