精简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 {
+public interface GroupedTypeGetter<K, G> {
-	/*-------------------------- 基本类型 start -------------------------------*/
+
 	/**
-	 * 获取字符串型属性值<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);
+	default BigInteger getBigIntegerByGroup(final K key, final G group) {
-	/*-------------------------- 基本类型 end -------------------------------*/
+		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) {
+	public Object getObj(final String key, final Object defaultValue) {
-		return super.get(key);
+		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) {
+	public <T> T getBean(final String attr) {
-		final Object result = get(attr);
+		return (T) 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);
 	}
 
 	/**

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 map.getOrDefault(key, defaultValue);
-		return null != value ? value : 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>() {{
+		Assert.assertEquals(new HashMap<String, Integer>() {
-			put("1", 1);
+			private static final long serialVersionUID = 1L;
-			put("2", 2);
+
-			put("3", 3);
+			{
-		}}, identityMap);
+				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>() {{
+		Assert.assertEquals(new HashMap<Integer, String>() {
-			put(1, "dromara");
+			private static final long serialVersionUID = 1L;
-			put(2, "hutool");
+
-			put(3, "sweet");
+			{
-		}}, toZip);
+				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>>() {{
+		final Map<String, List<Integer>> map = new HashMap<String, List<Integer>>() {
-			put("1", singletonList(1));
+			private static final long serialVersionUID = 1L;
-			put("2", singletonList(2));
+
-			put("3", singletonList(3));
+			{
-		}};
+				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>>() {{
+		final Map<Boolean, List<Integer>> map = new HashMap<Boolean, List<Integer>>() {
-			put(Boolean.TRUE, singletonList(2));
+			private static final long serialVersionUID = 1L;
-			put(Boolean.FALSE, asList(1, 3));
+			{
-		}};
+				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);
 	}
 

hutool-db/src/main/java/cn/hutool/db/Entity.java

@@ -8,6 +8,7 @@ import cn.hutool.core.reflect.MethodUtil;
 import cn.hutool.core.text.StrUtil;
 import cn.hutool.core.util.ArrayUtil;
 import cn.hutool.core.util.CharsetUtil;
+import cn.hutool.core.util.ObjUtil;
 import cn.hutool.db.sql.SqlUtil;
 
 import java.nio.charset.Charset;
@@ -273,28 +274,28 @@ public class Entity extends Dict {
 	// -------------------------------------------------------------------- Get start
 
 	/**
-	 * 获得Clob类型结果
+	 * 获得Clob类型结果，如果结果类型非Clob，不做转换，直接抛出异常
 	 *
 	 * @param field 参数
 	 * @return Clob
 	 */
 	public Clob getClob(final String field) {
-		return get(field, null);
+		return (Clob) get(field);
 	}
 
 	/**
-	 * 获得Blob类型结果
+	 * 获得Blob类型结果，如果结果类型非Blob，不做转换，直接抛出异常
 	 *
 	 * @param field 参数
 	 * @return Blob
 	 * @since 3.0.6
 	 */
 	public Blob getBlob(final String field) {
-		return get(field, null);
+		return (Blob) get(field);
 	}
 
 	@Override
-	public Time getTime(final String field) {
+	public Time getSqlTime(final String field, final Time defaultValue) {
 		final Object obj = get(field);
 		Time result = null;
 		if (null != obj) {
@@ -305,11 +306,11 @@ public class Entity extends Dict {
 				result = MethodUtil.invoke(obj, "timeValue");
 			}
 		}
-		return result;
+		return ObjUtil.defaultIfNull(result, defaultValue);
 	}
 
 	@Override
-	public Date getDate(final String field) {
+	public Date getDate(final String field, final Date defaultValue) {
 		final Object obj = get(field);
 		Date result = null;
 		if (null != obj) {
@@ -320,11 +321,11 @@ public class Entity extends Dict {
 				result = MethodUtil.invoke(obj, "dateValue");
 			}
 		}
-		return result;
+		return ObjUtil.defaultIfNull(result, defaultValue);
 	}
 
 	@Override
-	public Timestamp getTimestamp(final String field) {
+	public Timestamp getSqlTimestamp(final String field, final Timestamp defaultValue) {
 		final Object obj = get(field);
 		Timestamp result = null;
 		if (null != obj) {
@@ -335,12 +336,12 @@ public class Entity extends Dict {
 				result = MethodUtil.invoke(obj, "timestampValue");
 			}
 		}
-		return result;
+		return ObjUtil.defaultIfNull(result, defaultValue);
 	}
 
 	@Override
-	public String getStr(final String field) {
+	public String getStr(final String field, final String defaultValue) {
-		return getStr(field, CharsetUtil.UTF_8);
+		return getStr(field, CharsetUtil.UTF_8, defaultValue);
 	}
 
 	/**
@@ -350,10 +351,9 @@ public class Entity extends Dict {
 	 * @param field   字段名
 	 * @param charset 编码
 	 * @return 字段对应值
-	 * @since 3.0.6
 	 */
-	public String getStr(final String field, final Charset charset) {
+	public String getStr(final String field, final Charset charset, final String defaultValue) {
-		final Object obj = get(field);
+		final Object obj = getObj(field, defaultValue);
 		if (obj instanceof Clob) {
 			return SqlUtil.clobToStr((Clob) obj);
 		} else if (obj instanceof Blob) {
@@ -362,7 +362,7 @@ public class Entity extends Dict {
 			final RowId rowId = (RowId) obj;
 			return StrUtil.str(rowId.getBytes(), charset);
 		}
-		return super.getStr(field);
+		return super.getStr(field, defaultValue);
 	}
 
 	/**

hutool-db/src/main/java/cn/hutool/db/ds/AbstractDSFactory.java

@@ -102,7 +102,7 @@ public abstract class AbstractDSFactory extends DSFactory {
 		}
 
 		// 基本信息
-		final String url = config.getAndRemoveStr(KEY_ALIAS_URL);
+		final String url = config.getAndRemove(KEY_ALIAS_URL);
 		if (StrUtil.isBlank(url)) {
 			throw new DbRuntimeException("No JDBC URL for group: [{}]", group);
 		}
@@ -112,12 +112,12 @@ public abstract class AbstractDSFactory extends DSFactory {
 		DbUtil.removeShowSqlParams(config);
 
 		// 自动识别Driver
-		String driver = config.getAndRemoveStr(KEY_ALIAS_DRIVER);
+		String driver = config.getAndRemove(KEY_ALIAS_DRIVER);
 		if (StrUtil.isBlank(driver)) {
 			driver = DriverUtil.identifyDriver(url);
 		}
-		final String user = config.getAndRemoveStr(KEY_ALIAS_USER);
+		final String user = config.getAndRemove(KEY_ALIAS_USER);
-		final String pass = config.getAndRemoveStr(KEY_ALIAS_PASSWORD);
+		final String pass = config.getAndRemove(KEY_ALIAS_PASSWORD);
 
 		return DataSourceWrapper.wrap(createDataSource(url, driver, user, pass, config), driver);
 	}

hutool-db/src/main/java/cn/hutool/db/ds/bee/BeeDSFactory.java

@@ -36,7 +36,7 @@ public class BeeDSFactory extends AbstractDSFactory {
 		// remarks等特殊配置，since 5.3.8
 		String connValue;
 		for (final String key : KEY_CONN_PROPS) {
-			connValue = poolSetting.getAndRemoveStr(key);
+			connValue = poolSetting.getAndRemove(key);
 			if(StrUtil.isNotBlank(connValue)){
 				beeConfig.addConnectProperty(key, connValue);
 			}

hutool-db/src/main/java/cn/hutool/db/ds/c3p0/C3p0DSFactory.java

@@ -46,7 +46,7 @@ public class C3p0DSFactory extends AbstractDSFactory {
 		final Props connProps = new Props();
 		String connValue;
 		for (final String key : KEY_CONN_PROPS) {
-			connValue = poolSetting.getAndRemoveStr(key);
+			connValue = poolSetting.getAndRemove(key);
 			if(StrUtil.isNotBlank(connValue)){
 				connProps.setProperty(key, connValue);
 			}

hutool-db/src/main/java/cn/hutool/db/ds/dbcp/DbcpDSFactory.java

@@ -38,7 +38,7 @@ public class DbcpDSFactory extends AbstractDSFactory {
 		// remarks等特殊配置，since 5.3.8
 		String connValue;
 		for (final String key : KEY_CONN_PROPS) {
-			connValue = poolSetting.getAndRemoveStr(key);
+			connValue = poolSetting.getAndRemove(key);
 			if(StrUtil.isNotBlank(connValue)){
 				ds.addConnectionProperty(key, connValue);
 			}

hutool-db/src/main/java/cn/hutool/db/ds/druid/DruidDSFactory.java

@@ -49,7 +49,7 @@ public class DruidDSFactory extends AbstractDSFactory {
 		// Druid中也可以通过 druid.connectProperties 属性设置
 		String connValue;
 		for (final String key : KEY_CONN_PROPS) {
-			connValue = poolSetting.getAndRemoveStr(key);
+			connValue = poolSetting.getAndRemove(key);
 			if(StrUtil.isNotBlank(connValue)){
 				ds.addConnectionProperty(key, connValue);
 			}

hutool-db/src/main/java/cn/hutool/db/ds/hikari/HikariDSFactory.java

@@ -34,7 +34,7 @@ public class HikariDSFactory extends AbstractDSFactory {
 		final Props connProps = new Props();
 		String connValue;
 		for (final String key : KEY_CONN_PROPS) {
-			connValue = poolSetting.getAndRemoveStr(key);
+			connValue = poolSetting.getAndRemove(key);
 			if(StrUtil.isNotBlank(connValue)){
 				connProps.setProperty(key, connValue);
 			}

hutool-db/src/main/java/cn/hutool/db/ds/pooled/DbSetting.java

@@ -54,22 +54,22 @@ public class DbSetting {
 		final DbConfig dbConfig = new DbConfig();
 
 		// 基本信息
-		final String url = config.getAndRemoveStr(DSFactory.KEY_ALIAS_URL);
+		final String url = config.getAndRemove(DSFactory.KEY_ALIAS_URL);
 		if (StrUtil.isBlank(url)) {
 			throw new DbRuntimeException("No JDBC URL for group: [{}]", group);
 		}
 		dbConfig.setUrl(url);
 		// 自动识别Driver
-		final String driver = config.getAndRemoveStr(DSFactory.KEY_ALIAS_DRIVER);
+		final String driver = config.getAndRemove(DSFactory.KEY_ALIAS_DRIVER);
 		dbConfig.setDriver(StrUtil.isNotBlank(driver) ? driver : DriverUtil.identifyDriver(url));
-		dbConfig.setUser(config.getAndRemoveStr(DSFactory.KEY_ALIAS_USER));
+		dbConfig.setUser(config.getAndRemove(DSFactory.KEY_ALIAS_USER));
-		dbConfig.setPass(config.getAndRemoveStr(DSFactory.KEY_ALIAS_PASSWORD));
+		dbConfig.setPass(config.getAndRemove(DSFactory.KEY_ALIAS_PASSWORD));
 
 		// 连接池相关信息
-		dbConfig.setInitialSize(setting.getInt("initialSize", group, 0));
+		dbConfig.setInitialSize(setting.getIntByGroup("initialSize", group, 0));
-		dbConfig.setMinIdle(setting.getInt("minIdle", group, 0));
+		dbConfig.setMinIdle(setting.getIntByGroup("minIdle", group, 0));
-		dbConfig.setMaxActive(setting.getInt("maxActive", group, 8));
+		dbConfig.setMaxActive(setting.getIntByGroup("maxActive", group, 8));
-		dbConfig.setMaxWait(setting.getLong("maxWait", group, 6000L));
+		dbConfig.setMaxWait(setting.getLongByGroup("maxWait", group, 6000L));
 
 		// remarks等特殊配置，since 5.3.8
 		String connValue;

hutool-db/src/main/java/cn/hutool/db/ds/simple/SimpleDataSource.java

@@ -86,10 +86,10 @@ public class SimpleDataSource extends AbstractDataSource {
 		}
 
 		init(//
-				config.getAndRemoveStr(DSFactory.KEY_ALIAS_URL), //
+				config.getAndRemove(DSFactory.KEY_ALIAS_URL), //
-				config.getAndRemoveStr(DSFactory.KEY_ALIAS_USER), //
+				config.getAndRemove(DSFactory.KEY_ALIAS_USER), //
-				config.getAndRemoveStr(DSFactory.KEY_ALIAS_PASSWORD), //
+				config.getAndRemove(DSFactory.KEY_ALIAS_PASSWORD), //
-				config.getAndRemoveStr(DSFactory.KEY_ALIAS_DRIVER)//
+				config.getAndRemove(DSFactory.KEY_ALIAS_DRIVER)//
 		);
 
 		// 其它连接参数

hutool-db/src/main/java/cn/hutool/db/ds/tomcat/TomcatDSFactory.java

@@ -46,7 +46,7 @@ public class TomcatDSFactory extends AbstractDSFactory {
 		final Props connProps = new Props();
 		String connValue;
 		for (final String key : KEY_CONN_PROPS) {
-			connValue = poolSetting.getAndRemoveStr(key);
+			connValue = poolSetting.getAndRemove(key);
 			if(StrUtil.isNotBlank(connValue)){
 				connProps.setProperty(key, connValue);
 			}

hutool-json/src/main/java/cn/hutool/json/JSONConfig.java

@@ -271,7 +271,7 @@ public class JSONConfig implements Serializable {
 	 * @return this
 	 * @since 5.8.5
 	 */
-	public JSONConfig setCheckDuplicate(boolean checkDuplicate) {
+	public JSONConfig setCheckDuplicate(final boolean checkDuplicate) {
 		this.checkDuplicate = checkDuplicate;
 		return this;
 	}

hutool-json/src/main/java/cn/hutool/json/JSONGetter.java

@@ -1,11 +1,9 @@
 package cn.hutool.json;
 
-import cn.hutool.core.convert.ConvertException;
+import cn.hutool.core.lang.getter.TypeGetter;
-import cn.hutool.core.lang.getter.OptNullBasicTypeFromObjectGetter;
 import cn.hutool.core.util.ObjUtil;
 
-import java.time.LocalDateTime;
+import java.lang.reflect.Type;
-import java.util.Date;
 import java.util.List;
 
 /**
@@ -14,7 +12,7 @@ import java.util.List;
  * @param <K> Key类型
  * @author Looly
  */
-public interface JSONGetter<K> extends OptNullBasicTypeFromObjectGetter<K> {
+public interface JSONGetter<K> extends TypeGetter<K> {
 
 	/**
 	 * 获取JSON配置
@@ -126,49 +124,12 @@ public interface JSONGetter<K> extends OptNullBasicTypeFromObjectGetter<K> {
 	}
 
 	@Override
-	default Date getDate(final K key, final Date defaultValue) {
+	default <T> T get(final K key, final Type type, final T defaultValue) {
-		return get(key, Date.class);
-	}
-
-	/**
-	 * 获取{@link LocalDateTime}类型值
-	 *
-	 * @param key          键
-	 * @param defaultValue 默认值
-	 * @return {@link LocalDateTime}
-	 * @since 5.7.7
-	 */
-	default LocalDateTime getLocalDateTime(final K key, final LocalDateTime defaultValue) {
-		return ObjUtil.defaultIfNull(get(key, LocalDateTime.class), defaultValue);
-	}
-
-	/**
-	 * 获取byte[]数据
-	 *
-	 * @param key 键
-	 * @return 值
-	 */
-	default byte[] getBytes(final K key) {
-		return get(key, byte[].class);
-	}
-
-	/**
-	 * 获取指定类型的对象
-	 *
-	 * @param <T>         获取的对象类型
-	 * @param key         键
-	 * @param type        获取对象类型
-	 * @return 对象
-	 * @throws ConvertException 转换异常
-	 * @since 3.0.8
-	 */
-	@SuppressWarnings("unchecked")
-	default <T> T get(final K key, final Class<T> type) throws ConvertException {
 		final Object value = this.getObj(key);
 		if (ObjUtil.isNull(value)) {
-			return null;
+			return defaultValue;
 		}
 
-		return (T) getConfig().getConverter().convert(type, value);
+		return (T) getConfig().getConverter().convert(type, value, defaultValue);
 	}
 }

hutool-setting/src/main/java/cn/hutool/setting/AbsSetting.java

@@ -3,13 +3,11 @@ package cn.hutool.setting;
 import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.bean.copier.CopyOptions;
 import cn.hutool.core.bean.copier.ValueProvider;
-import cn.hutool.core.convert.Convert;
+import cn.hutool.core.lang.getter.GroupedTypeGetter;
-import cn.hutool.core.lang.getter.OptNullBasicTypeFromStringGetter;
+import cn.hutool.core.lang.getter.TypeGetter;
 import cn.hutool.core.reflect.ConstructorUtil;
 import cn.hutool.core.text.StrUtil;
 import cn.hutool.core.util.ObjUtil;
-import cn.hutool.log.Log;
-import cn.hutool.log.LogFactory;
 
 import java.io.Serializable;
 import java.lang.reflect.Type;
@@ -19,35 +17,22 @@ import java.lang.reflect.Type;
  *
  * @author Looly
  */
-public abstract class AbsSetting implements OptNullBasicTypeFromStringGetter<String>, Serializable {
+public abstract class AbsSetting implements TypeGetter<CharSequence>,
+		GroupedTypeGetter<CharSequence, CharSequence>, Serializable {
 	private static final long serialVersionUID = 6200156302595905863L;
-	private final static Log log = LogFactory.get();
 
 	/**
 	 * 数组类型值默认分隔符
 	 */
-	public final static String DEFAULT_DELIMITER = ",";
+	public final static String DEFAULT_DELIMITER = StrUtil.COMMA;
 	/**
 	 * 默认分组
 	 */
 	public final static String DEFAULT_GROUP = StrUtil.EMPTY;
 
 	@Override
-	public String getStr(final String key, final String defaultValue) {
+	public Object getObj(final CharSequence key, final Object defaultValue) {
-		return getStr(key, DEFAULT_GROUP, defaultValue);
+		return ObjUtil.defaultIfNull(getObjByGroup(key, DEFAULT_GROUP), defaultValue);
-	}
-
-	/**
-	 * 获得字符串类型值
-	 *
-	 * @param key          KEY
-	 * @param group        分组
-	 * @param defaultValue 默认值
-	 * @return 值，如果字符串为{@code null}返回默认值
-	 */
-	public String getStr(final String key, final String group, final String defaultValue) {
-		final String value = getByGroup(key, group);
-		return ObjUtil.defaultIfNull(value, defaultValue);
 	}
 
 	/**
@@ -57,53 +42,11 @@ public abstract class AbsSetting implements OptNullBasicTypeFromStringGetter<Str
 	 * @param group        分组
 	 * @param defaultValue 默认值
 	 * @return 值，如果字符串为{@code null}或者""返回默认值
-	 * @since 5.2。4
 	 */
-	public String getStrNotEmpty(final String key, final String group, final String defaultValue) {
+	public String getByGroupNotEmpty(final String key, final String group, final String defaultValue) {
-		final String value = getByGroup(key, group);
+		final String value = getStrByGroup(key, group);
 		return StrUtil.defaultIfEmpty(value, defaultValue);
 	}
-
-	/**
-	 * 获得指定分组的键对应值
-	 *
-	 * @param key   键
-	 * @param group 分组
-	 * @return 值
-	 */
-	public abstract String getByGroup(String key, String group);
-
-	// --------------------------------------------------------------- Get
-
-	/**
-	 * 带有日志提示的get，如果没有定义指定的KEY，则打印debug日志
-	 *
-	 * @param key 键
-	 * @return 值
-	 */
-	public String getWithLog(final String key) {
-		final String value = getStr(key);
-		if (value == null) {
-			log.debug("No key define for [{}]!", key);
-		}
-		return value;
-	}
-
-	/**
-	 * 带有日志提示的get，如果没有定义指定的KEY，则打印debug日志
-	 *
-	 * @param key   键
-	 * @param group 分组
-	 * @return 值
-	 */
-	public String getByGroupWithLog(final String key, final String group) {
-		final String value = getByGroup(key, group);
-		if (value == null) {
-			log.debug("No key define for [{}] of group [{}] !", key, group);
-		}
-		return value;
-	}
-
 	// --------------------------------------------------------------- Get string array
 
 	/**
@@ -112,8 +55,8 @@ public abstract class AbsSetting implements OptNullBasicTypeFromStringGetter<Str
 	 * @param key 属性名
 	 * @return 属性值
 	 */
-	public String[] getStrings(final String key) {
+	public String[] getStrs(final String key) {
-		return getStrings(key, null);
+		return getStrs(key, null);
 	}
 
 	/**
@@ -123,8 +66,8 @@ public abstract class AbsSetting implements OptNullBasicTypeFromStringGetter<Str
 	 * @param defaultValue 默认的值
 	 * @return 属性值
 	 */
-	public String[] getStringsWithDefault(final String key, final String[] defaultValue) {
+	public String[] getStrs(final CharSequence key, final String[] defaultValue) {
-		String[] value = getStrings(key, null);
+		String[] value = getStrsByGroup(key, null);
 		if (null == value) {
 			value = defaultValue;
 		}
@@ -133,149 +76,42 @@ public abstract class AbsSetting implements OptNullBasicTypeFromStringGetter<Str
 	}
 
 	/**
-	 * 获得数组型
+	 * 获得数组型默认逗号分隔<br>
+	 * 若配置文件中键值对类似于：
+	 * <pre>
+	 *     a = 1,2,3,4
+	 * </pre>
+	 * 则获取结果为：[1, 2, 3, 4]
 	 *
 	 * @param key   属性名
 	 * @param group 分组名
 	 * @return 属性值
 	 */
-	public String[] getStrings(final String key, final String group) {
+	public String[] getStrsByGroup(final CharSequence key, final CharSequence group) {
-		return getStrings(key, group, DEFAULT_DELIMITER);
+		return getStrsByGroup(key, group, DEFAULT_DELIMITER);
 	}
 
 	/**
-	 * 获得数组型
+	 * 获得数组型，可自定义分隔符<br>
+	 * 假定分隔符为逗号，若配置文件中键值对类似于：
+	 * <pre>
+	 *     a = 1,2,3,4
+	 * </pre>
+	 * 则获取结果为：[1, 2, 3, 4]
 	 *
 	 * @param key       属性名
 	 * @param group     分组名
 	 * @param delimiter 分隔符
 	 * @return 属性值
 	 */
-	public String[] getStrings(final String key, final String group, final String delimiter) {
+	public String[] getStrsByGroup(final CharSequence key, final CharSequence group, final CharSequence delimiter) {
-		final String value = getByGroup(key, group);
+		final String value = getStrByGroup(key, group);
 		if (StrUtil.isBlank(value)) {
 			return null;
 		}
 		return StrUtil.splitToArray(value, delimiter);
 	}
 
-	// --------------------------------------------------------------- Get int
-
-	/**
-	 * 获取数字型型属性值
-	 *
-	 * @param key   属性名
-	 * @param group 分组名
-	 * @return 属性值
-	 */
-	public Integer getInt(final String key, final String group) {
-		return getInt(key, group, null);
-	}
-
-	/**
-	 * 获取数字型型属性值
-	 *
-	 * @param key          属性名
-	 * @param group        分组名
-	 * @param defaultValue 默认值
-	 * @return 属性值
-	 */
-	public Integer getInt(final String key, final String group, final Integer defaultValue) {
-		return Convert.toInt(getByGroup(key, group), defaultValue);
-	}
-
-	// --------------------------------------------------------------- Get bool
-
-	/**
-	 * 获取布尔型属性值
-	 *
-	 * @param key   属性名
-	 * @param group 分组名
-	 * @return 属性值
-	 */
-	public Boolean getBool(final String key, final String group) {
-		return getBool(key, group, null);
-	}
-
-	/**
-	 * 获取布尔型属性值
-	 *
-	 * @param key          属性名
-	 * @param group        分组名
-	 * @param defaultValue 默认值
-	 * @return 属性值
-	 */
-	public Boolean getBool(final String key, final String group, final Boolean defaultValue) {
-		return Convert.toBool(getByGroup(key, group), defaultValue);
-	}
-
-	// --------------------------------------------------------------- Get long
-
-	/**
-	 * 获取long类型属性值
-	 *
-	 * @param key   属性名
-	 * @param group 分组名
-	 * @return 属性值
-	 */
-	public Long getLong(final String key, final String group) {
-		return getLong(key, group, null);
-	}
-
-	/**
-	 * 获取long类型属性值
-	 *
-	 * @param key          属性名
-	 * @param group        分组名
-	 * @param defaultValue 默认值
-	 * @return 属性值
-	 */
-	public Long getLong(final String key, final String group, final Long defaultValue) {
-		return Convert.toLong(getByGroup(key, group), defaultValue);
-	}
-
-	// --------------------------------------------------------------- Get char
-
-	/**
-	 * 获取char类型属性值
-	 *
-	 * @param key   属性名
-	 * @param group 分组名
-	 * @return 属性值
-	 */
-	public Character getChar(final String key, final String group) {
-		final String value = getByGroup(key, group);
-		if (StrUtil.isBlank(value)) {
-			return null;
-		}
-		return value.charAt(0);
-	}
-
-	// --------------------------------------------------------------- Get double
-
-	/**
-	 * 获取double类型属性值
-	 *
-	 * @param key   属性名
-	 * @param group 分组名
-	 * @return 属性值
-	 */
-	public Double getDouble(final String key, final String group) {
-		return getDouble(key, group, null);
-	}
-
-	/**
-	 * 获取double类型属性值
-	 *
-	 * @param key          属性名
-	 * @param group        分组名
-	 * @param defaultValue 默认值
-	 * @return 属性值
-	 */
-	public Double getDouble(final String key, final String group, final Double defaultValue) {
-		return Convert.toDouble(getByGroup(key, group), defaultValue);
-	}
-
 	/**
 	 * 将setting中的键值关系映射到对象中，原理是调用对象对应的set方法<br>
 	 * 只支持基本类型的转换
@@ -285,17 +121,17 @@ public abstract class AbsSetting implements OptNullBasicTypeFromStringGetter<Str
 	 * @param bean  Bean对象
 	 * @return Bean
 	 */
-	public <T> T toBean(final String group, final T bean) {
+	public <T> T toBean(final CharSequence group, final T bean) {
 		return BeanUtil.fillBean(bean, new ValueProvider<String>() {
 
 			@Override
 			public Object value(final String key, final Type valueType) {
-				return getByGroup(key, group);
+				return getObjByGroup(key, group);
 			}
 
 			@Override
 			public boolean containsKey(final String key) {
-				return null != getByGroup(key, group);
+				return null != getObjByGroup(key, group);
 			}
 		}, CopyOptions.of());
 	}
@@ -310,7 +146,7 @@ public abstract class AbsSetting implements OptNullBasicTypeFromStringGetter<Str
 	 * @return Bean
 	 * @since 5.0.6
 	 */
-	public <T> T toBean(final String group, final Class<T> beanClass) {
+	public <T> T toBean(final CharSequence group, final Class<T> beanClass) {
 		return toBean(group, ConstructorUtil.newInstanceIfPossible(beanClass));
 	}
 

hutool-setting/src/main/java/cn/hutool/setting/GroupedMap.java

@@ -35,12 +35,12 @@ public class GroupedMap extends LinkedHashMap<String, LinkedHashMap<String, Stri
 	 * @param key 键
 	 * @return 值，如果分组不存在或者值不存在则返回null
 	 */
-	public String get(final String group, final String key) {
+	public String get(final CharSequence group, final CharSequence key) {
 		readLock.lock();
 		try {
 			final LinkedHashMap<String, String> map = this.get(StrUtil.emptyIfNull(group));
 			if (MapUtil.isNotEmpty(map)) {
-				return map.get(key);
+				return map.get(StrUtil.str(key));
 			}
 		} finally {
 			readLock.unlock();

hutool-setting/src/main/java/cn/hutool/setting/Setting.java

@@ -4,11 +4,8 @@ import cn.hutool.core.collection.ListUtil;
 import cn.hutool.core.convert.Convert;
 import cn.hutool.core.io.FileUtil;
 import cn.hutool.core.io.IoUtil;
-import cn.hutool.core.io.resource.ClassPathResource;
-import cn.hutool.core.io.resource.FileResource;
 import cn.hutool.core.io.resource.Resource;
 import cn.hutool.core.io.resource.ResourceUtil;
-import cn.hutool.core.io.resource.UrlResource;
 import cn.hutool.core.io.watch.SimpleWatcher;
 import cn.hutool.core.io.watch.WatchMonitor;
 import cn.hutool.core.io.watch.WatchUtil;
@@ -85,6 +82,11 @@ public class Setting extends AbsSetting implements Map<String, String> {
 	 */
 	protected Resource resource;
 
+	/**
+	 * 当获取key对应值为{@code null}时是否打印debug日志提示用户，默认{@code false}
+	 */
+	private boolean logIfNull;
+
 	private SettingLoader settingLoader;
 	private WatchMonitor watchMonitor;
 
@@ -137,32 +139,7 @@ public class Setting extends AbsSetting implements Map<String, String> {
 	 */
 	public Setting(final File configFile, final Charset charset, final boolean isUseVariable) {
 		Assert.notNull(configFile, "Null setting file define!");
-		this.init(new FileResource(configFile), charset, isUseVariable);
+		this.init(ResourceUtil.getResource(configFile), charset, isUseVariable);
-	}
-
-	/**
-	 * 构造，相对于classes读取文件
-	 *
-	 * @param path          相对ClassPath路径或绝对路径
-	 * @param clazz         基准类
-	 * @param charset       字符集
-	 * @param isUseVariable 是否使用变量
-	 */
-	public Setting(final String path, final Class<?> clazz, final Charset charset, final boolean isUseVariable) {
-		Assert.notBlank(path, "Blank setting path !");
-		this.init(new ClassPathResource(path, clazz), charset, isUseVariable);
-	}
-
-	/**
-	 * 构造
-	 *
-	 * @param url           设定文件的URL
-	 * @param charset       字符集
-	 * @param isUseVariable 是否使用变量
-	 */
-	public Setting(final URL url, final Charset charset, final boolean isUseVariable) {
-		Assert.notNull(url, "Null setting url define!");
-		this.init(new UrlResource(url), charset, isUseVariable);
 	}
 
 	/**
@@ -278,26 +255,12 @@ public class Setting extends AbsSetting implements Map<String, String> {
 	}
 
 	@Override
-	public String getByGroup(final String key, final String group) {
+	public Object getObjByGroup(final CharSequence key, final CharSequence group, final Object defaultValue) {
-		return this.groupedMap.get(group, key);
+		final String result = this.groupedMap.get(group, key);
-	}
+		if (result == null && logIfNull) {
-
+			StaticLog.debug("No key [{}] in group [{}] !", key, group);
-	/**
-	 * 获取并删除键值对，当指定键对应值非空时，返回并删除这个值，后边的键对应的值不再查找
-	 *
-	 * @param keys 键列表，常用于别名
-	 * @return 值
-	 * @since 3.1.2
-	 */
-	public Object getAndRemove(final String... keys) {
-		Object value = null;
-		for (final String key : keys) {
-			value = remove(key);
-			if (null != value) {
-				break;
-			}
 		}
-		return value;
+		return result;
 	}
 
 	/**
@@ -307,7 +270,7 @@ public class Setting extends AbsSetting implements Map<String, String> {
 	 * @return 字符串值
 	 * @since 3.1.2
 	 */
-	public String getAndRemoveStr(final String... keys) {
+	public String getAndRemove(final String... keys) {
 		String value = null;
 		for (final String key : keys) {
 			value = remove(key);
@@ -467,6 +430,16 @@ public class Setting extends AbsSetting implements Map<String, String> {
 		return this;
 	}
 
+	/**
+	 * 设置当获取key对应值为{@code null}时是否打印debug日志提示用户
+	 * @param logIfNull 当获取key对应值为{@code null}时是否打印debug日志提示用户
+	 * @return this
+	 */
+	public Setting setLogIfNull(final boolean logIfNull){
+		this.logIfNull = logIfNull;
+		return this;
+	}
+
 	// ------------------------------------------------- Map interface with group
 
 	/**
@@ -501,17 +474,6 @@ public class Setting extends AbsSetting implements Map<String, String> {
 		return this.groupedMap.containsValue(group, value);
 	}
 
-	/**
-	 * 获取分组对应的值，如果分组不存在或者值不存在则返回null
-	 *
-	 * @param group 分组
-	 * @param key   键
-	 * @return 值，如果分组不存在或者值不存在则返回null
-	 */
-	public String get(final String group, final String key) {
-		return this.groupedMap.get(group, key);
-	}
-
 	/**
 	 * 将键值对加入到对应分组中
 	 *
@@ -666,7 +628,7 @@ public class Setting extends AbsSetting implements Map<String, String> {
 	 */
 	@Override
 	public String get(final Object key) {
-		return this.groupedMap.get(DEFAULT_GROUP, Convert.toStr(key));
+		return getStr((String)key);
 	}
 
 	/**
@@ -689,7 +651,7 @@ public class Setting extends AbsSetting implements Map<String, String> {
 	 */
 	@Override
 	public String remove(final Object key) {
-		return this.groupedMap.remove(DEFAULT_GROUP, Convert.toStr(key));
+		return remove(DEFAULT_GROUP, key);
 	}
 
 	/**

hutool-setting/src/main/java/cn/hutool/setting/dialect/Props.java

@@ -1,12 +1,9 @@
 package cn.hutool.setting.dialect;
 
 import cn.hutool.core.bean.BeanUtil;
-import cn.hutool.core.convert.Convert;
 import cn.hutool.core.io.FileUtil;
 import cn.hutool.core.io.IORuntimeException;
 import cn.hutool.core.io.IoUtil;
-import cn.hutool.core.io.resource.ClassPathResource;
-import cn.hutool.core.io.resource.FileResource;
 import cn.hutool.core.io.resource.Resource;
 import cn.hutool.core.io.resource.ResourceUtil;
 import cn.hutool.core.io.resource.UrlResource;
@@ -14,26 +11,22 @@ import cn.hutool.core.io.watch.SimpleWatcher;
 import cn.hutool.core.io.watch.WatchMonitor;
 import cn.hutool.core.io.watch.WatchUtil;
 import cn.hutool.core.lang.Assert;
-import cn.hutool.core.lang.getter.BasicTypeGetter;
+import cn.hutool.core.lang.getter.TypeGetter;
-import cn.hutool.core.lang.getter.OptBasicTypeGetter;
 import cn.hutool.core.map.MapUtil;
 import cn.hutool.core.reflect.ConstructorUtil;
 import cn.hutool.core.text.StrUtil;
 import cn.hutool.core.util.CharsetUtil;
+import cn.hutool.core.util.ObjUtil;
 import cn.hutool.log.StaticLog;
 
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.IOException;
 import java.io.Writer;
-import java.math.BigDecimal;
-import java.math.BigInteger;
 import java.net.URL;
 import java.nio.charset.Charset;
-import java.nio.charset.StandardCharsets;
 import java.nio.file.Path;
 import java.nio.file.WatchEvent;
-import java.util.Date;
 import java.util.Properties;
 
 /**
@@ -41,7 +34,7 @@ import java.util.Properties;
  *
  * @author loolly
  */
-public final class Props extends Properties implements BasicTypeGetter<String>, OptBasicTypeGetter<String> {
+public final class Props extends Properties implements TypeGetter<CharSequence> {
 	private static final long serialVersionUID = 1935981579709590740L;
 
 	/**
@@ -78,29 +71,18 @@ public final class Props extends Properties implements BasicTypeGetter<String>,
 	 * @param resource 资源（相对Classpath的路径）
 	 * @return Props
 	 */
-	public static Props getProp(final String resource) {
+	public static Props of(final String resource) {
 		return new Props(resource);
 	}
 
-	/**
-	 * 获得Classpath下的Properties文件
-	 *
-	 * @param resource    资源（相对Classpath的路径）
-	 * @param charsetName 字符集
-	 * @return Properties
-	 */
-	public static Props getProp(final String resource, final String charsetName) {
-		return new Props(resource, charsetName);
-	}
-
 	/**
 	 * 获得Classpath下的Properties文件
 	 *
 	 * @param resource 资源（相对Classpath的路径）
-	 * @param charset  字符集
+	 * @param charset  自定义编码
 	 * @return Properties
 	 */
-	public static Props getProp(final String resource, final Charset charset) {
+	public static Props of(final String resource, final Charset charset) {
 		return new Props(resource, charset);
 	}
 
@@ -118,24 +100,14 @@ public final class Props extends Properties implements BasicTypeGetter<String>,
 	 * @param path 配置文件路径，相对于ClassPath，或者使用绝对路径
 	 */
 	public Props(final String path) {
-		this(path, CharsetUtil.ISO_8859_1);
+		this(path, null);
-	}
-
-	/**
-	 * 构造，使用相对于Class文件根目录的相对路径
-	 *
-	 * @param path        相对或绝对路径
-	 * @param charsetName 字符集
-	 */
-	public Props(final String path, final String charsetName) {
-		this(path, CharsetUtil.charset(charsetName));
 	}
 
 	/**
 	 * 构造，使用相对于Class文件根目录的相对路径
 	 *
 	 * @param path    相对或绝对路径
-	 * @param charset 字符集
+	 * @param charset 自定义编码
 	 */
 	public Props(final String path, final Charset charset) {
 		Assert.notBlank(path, "Blank properties file path !");
@@ -151,98 +123,35 @@ public final class Props extends Properties implements BasicTypeGetter<String>,
 	 * @param propertiesFile 配置文件对象
 	 */
 	public Props(final File propertiesFile) {
-		this(propertiesFile, StandardCharsets.ISO_8859_1);
+		this(propertiesFile, null);
 	}
 
 	/**
 	 * 构造
 	 *
 	 * @param propertiesFile 配置文件对象
-	 * @param charsetName    字符集
+	 * @param charset        自定义编码
-	 */
-	public Props(final File propertiesFile, final String charsetName) {
-		this(propertiesFile, Charset.forName(charsetName));
-	}
-
-	/**
-	 * 构造
-	 *
-	 * @param propertiesFile 配置文件对象
-	 * @param charset        字符集
 	 */
 	public Props(final File propertiesFile, final Charset charset) {
 		Assert.notNull(propertiesFile, "Null properties file!");
-		this.charset = charset;
-		this.load(new FileResource(propertiesFile));
-	}
-
-	/**
-	 * 构造，相对于classes读取文件
-	 *
-	 * @param path  相对路径
-	 * @param clazz 基准类
-	 */
-	public Props(final String path, final Class<?> clazz) {
-		this(path, clazz, CharsetUtil.NAME_ISO_8859_1);
-	}
-
-	/**
-	 * 构造，相对于classes读取文件
-	 *
-	 * @param path        相对路径
-	 * @param clazz       基准类
-	 * @param charsetName 字符集
-	 */
-	public Props(final String path, final Class<?> clazz, final String charsetName) {
-		this(path, clazz, CharsetUtil.charset(charsetName));
-	}
-
-	/**
-	 * 构造，相对于classes读取文件
-	 *
-	 * @param path    相对路径
-	 * @param clazz   基准类
-	 * @param charset 字符集
-	 */
-	public Props(final String path, final Class<?> clazz, final Charset charset) {
-		Assert.notBlank(path, "Blank properties file path !");
 		if (null != charset) {
 			this.charset = charset;
 		}
-		this.load(new ClassPathResource(path, clazz));
+		this.load(ResourceUtil.getResource(propertiesFile));
 	}
 
 	/**
 	 * 构造，使用URL读取
 	 *
-	 * @param propertiesUrl 属性文件路径
+	 * @param resource {@link Resource}
+	 * @param charset  自定义编码
 	 */
-	public Props(final URL propertiesUrl) {
+	public Props(final Resource resource, final Charset charset) {
-		this(propertiesUrl, StandardCharsets.ISO_8859_1);
+		Assert.notNull(resource, "Null properties URL !");
-	}
-
-	/**
-	 * 构造，使用URL读取
-	 *
-	 * @param propertiesUrl 属性文件路径
-	 * @param charsetName   字符集
-	 */
-	public Props(final URL propertiesUrl, final String charsetName) {
-		this(propertiesUrl, CharsetUtil.charset(charsetName));
-	}
-
-	/**
-	 * 构造，使用URL读取
-	 *
-	 * @param propertiesUrl 属性文件路径
-	 * @param charset       字符集
-	 */
-	public Props(final URL propertiesUrl, final Charset charset) {
-		Assert.notNull(propertiesUrl, "Null properties URL !");
 		if (null != charset) {
 			this.charset = charset;
 		}
-		this.load(propertiesUrl);
+		this.load(resource);
 	}
 
 	/**
@@ -316,167 +225,9 @@ public final class Props extends Properties implements BasicTypeGetter<String>,
 		}
 	}
 
-	// ----------------------------------------------------------------------- Get start
 	@Override
-	public Object getObj(final String key, final Object defaultValue) {
+	public Object getObj(final CharSequence key, final Object defaultValue) {
-		return getStr(key, null == defaultValue ? null : defaultValue.toString());
+		return ObjUtil.defaultIfNull(getProperty(StrUtil.str(key)), defaultValue);
-	}
-
-	@Override
-	public Object getObj(final String key) {
-		return getObj(key, null);
-	}
-
-	@Override
-	public String getStr(final String key, final String defaultValue) {
-		return super.getProperty(key, defaultValue);
-	}
-
-	@Override
-	public String getStr(final String key) {
-		return super.getProperty(key);
-	}
-
-	@Override
-	public Integer getInt(final String key, final Integer defaultValue) {
-		return Convert.toInt(getStr(key), defaultValue);
-	}
-
-	@Override
-	public Integer getInt(final String key) {
-		return getInt(key, null);
-	}
-
-	@Override
-	public Boolean getBool(final String key, final Boolean defaultValue) {
-		return Convert.toBool(getStr(key), defaultValue);
-	}
-
-	@Override
-	public Boolean getBool(final String key) {
-		return getBool(key, null);
-	}
-
-	@Override
-	public Long getLong(final String key, final Long defaultValue) {
-		return Convert.toLong(getStr(key), defaultValue);
-	}
-
-	@Override
-	public Long getLong(final String key) {
-		return getLong(key, null);
-	}
-
-	@Override
-	public Character getChar(final String key, final Character defaultValue) {
-		final String value = getStr(key);
-		if (StrUtil.isBlank(value)) {
-			return defaultValue;
-		}
-		return value.charAt(0);
-	}
-
-	@Override
-	public Character getChar(final String key) {
-		return getChar(key, null);
-	}
-
-	@Override
-	public Float getFloat(final String key) {
-		return getFloat(key, null);
-	}
-
-	@Override
-	public Float getFloat(final String key, final Float defaultValue) {
-		return Convert.toFloat(getStr(key), defaultValue);
-	}
-
-	@Override
-	public Double getDouble(final String key, final Double defaultValue) throws NumberFormatException {
-		return Convert.toDouble(getStr(key), defaultValue);
-	}
-
-	@Override
-	public Double getDouble(final String key) throws NumberFormatException {
-		return getDouble(key, null);
-	}
-
-	@Override
-	public Short getShort(final String key, final Short defaultValue) {
-		return Convert.toShort(getStr(key), defaultValue);
-	}
-
-	@Override
-	public Short getShort(final String key) {
-		return getShort(key, null);
-	}
-
-	@Override
-	public Byte getByte(final String key, final Byte defaultValue) {
-		return Convert.toByte(getStr(key), defaultValue);
-	}
-
-	@Override
-	public Byte getByte(final String key) {
-		return getByte(key, null);
-	}
-
-	@Override
-	public BigDecimal getBigDecimal(final String key, final BigDecimal defaultValue) {
-		final String valueStr = getStr(key);
-		if (StrUtil.isBlank(valueStr)) {
-			return defaultValue;
-		}
-
-		try {
-			return new BigDecimal(valueStr);
-		} catch (final Exception e) {
-			return defaultValue;
-		}
-	}
-
-	@Override
-	public BigDecimal getBigDecimal(final String key) {
-		return getBigDecimal(key, null);
-	}
-
-	@Override
-	public BigInteger getBigInteger(final String key, final BigInteger defaultValue) {
-		final String valueStr = getStr(key);
-		if (StrUtil.isBlank(valueStr)) {
-			return defaultValue;
-		}
-
-		try {
-			return new BigInteger(valueStr);
-		} catch (final Exception e) {
-			return defaultValue;
-		}
-	}
-
-	@Override
-	public BigInteger getBigInteger(final String key) {
-		return getBigInteger(key, null);
-	}
-
-	@Override
-	public <E extends Enum<E>> E getEnum(final Class<E> clazz, final String key, final E defaultValue) {
-		return Convert.toEnum(clazz, getStr(key), defaultValue);
-	}
-
-	@Override
-	public <E extends Enum<E>> E getEnum(final Class<E> clazz, final String key) {
-		return getEnum(clazz, key, null);
-	}
-
-	@Override
-	public Date getDate(final String key, final Date defaultValue) {
-		return Convert.toDate(getStr(key), defaultValue);
-	}
-
-	@Override
-	public Date getDate(final String key) {
-		return getDate(key, null);
 	}
 
 	/**

hutool-setting/src/test/java/cn/hutool/setting/PropsTest.java

@@ -1,8 +1,6 @@
 package cn.hutool.setting;
 
 import cn.hutool.core.date.DateUtil;
-import cn.hutool.log.LogFactory;
-import cn.hutool.log.dialect.console.ConsoleLogFactory;
 import cn.hutool.setting.dialect.Props;
 import lombok.Data;
 import org.junit.Assert;
@@ -16,7 +14,7 @@ import java.util.Map;
 import java.util.Objects;
 
 /**
- * Setting单元测试
+ * Props单元测试
  *
  * @author Looly
  *
@@ -25,7 +23,7 @@ public class PropsTest {
 
 	@Before
 	public void init() {
-		LogFactory.setCurrentLogFactory(ConsoleLogFactory.class);
+		//LogFactory.setCurrentLogFactory(ConsoleLogFactory.class);
 	}
 
 	@Test
@@ -53,7 +51,7 @@ public class PropsTest {
 
 	@Test
 	public void toBeanTest() {
-		final Props props = Props.getProp("to_bean_test.properties");
+		final Props props = Props.of("to_bean_test.properties");
 
 		final ConfigProperties cfg = props.toBean(ConfigProperties.class, "mail");
 		Assert.assertEquals("mailer@mail.com", cfg.getHost());

hutool-setting/src/test/java/cn/hutool/setting/SettingTest.java

@@ -17,15 +17,15 @@ public class SettingTest {
 		//noinspection MismatchedQueryAndUpdateOfCollection
 		final Setting setting = new Setting("test.setting", true);
 
-		final String driver = setting.getByGroup("driver", "demo");
+		final String driver = setting.getStrByGroup("driver", "demo");
 		Assert.assertEquals("com.mysql.jdbc.Driver", driver);
 
 		//本分组变量替换
-		final String user = setting.getByGroup("user", "demo");
+		final String user = setting.getStrByGroup("user", "demo");
 		Assert.assertEquals("rootcom.mysql.jdbc.Driver", user);
 
 		//跨分组变量替换
-		final String user2 = setting.getByGroup("user2", "demo");
+		final String user2 = setting.getStrByGroup("user2", "demo");
 		Assert.assertEquals("rootcom.mysql.jdbc.Driver", user2);
 
 		//默认值测试
@@ -50,9 +50,9 @@ public class SettingTest {
 		setting.setByGroup("user", "group3", "root3");
 		setting.set("user", "root4");
 
-		Assert.assertEquals("root", setting.getByGroup("user", "group1"));
+		Assert.assertEquals("root", setting.getStrByGroup("user", "group1"));
-		Assert.assertEquals("root2", setting.getByGroup("user", "group2"));
+		Assert.assertEquals("root2", setting.getStrByGroup("user", "group2"));
-		Assert.assertEquals("root3", setting.getByGroup("user", "group3"));
+		Assert.assertEquals("root3", setting.getStrByGroup("user", "group3"));
 		Assert.assertEquals("root4", setting.get("user"));
 	}
 

hutool-setting/src/test/java/cn/hutool/setting/SettingUtilTest.java

@@ -7,13 +7,13 @@ public class SettingUtilTest {
 
 	@Test
 	public void getTest() {
-		final String driver = SettingUtil.get("test").get("demo", "driver");
+		final String driver = SettingUtil.get("test").getStrByGroup("driver", "demo");
 		Assert.assertEquals("com.mysql.jdbc.Driver", driver);
 	}
 
 	@Test
 	public void getTest2() {
-		final String driver = SettingUtil.get("example/example").get("demo", "key");
+		final String driver = SettingUtil.get("example/example").getStrByGroup("key", "demo");
 		Assert.assertEquals("value", driver);
 	}
 
@@ -21,7 +21,7 @@ public class SettingUtilTest {
 	public void getFirstFoundTest() {
 		//noinspection ConstantConditions
 		final String driver = SettingUtil.getFirstFound("test2", "test")
-				.get("demo", "driver");
+				.getStrByGroup("driver", "demo");
 		Assert.assertEquals("com.mysql.jdbc.Driver", driver);
 	}
 }