ZhouXY108/hutool
1
0
Fork 0
mirror of https://gitee.com/chinabugotech/hutool.git synced 2025-05-09 23:51:34 +08:00
Code Issues Packages Projects Releases Wiki Activity

精简XXXTypeGetter

Browse Source
This commit is contained in:
Looly 2022-09-22 02:31:28 +08:00
parent b13329d781
commit f2629f775b
39 changed files with 969 additions and 1841 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
hutool-core/src/main/java/cn/hutool/core/collection/ListUtil.java
View File

@ -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();
}

7
hutool-core/src/main/java/cn/hutool/core/convert/Convert.java
View File

@ -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”

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

@ -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);
}
}

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

@ -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 -------------------------------*/
}

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

@ -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 -------------------------------*/
}

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

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

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

@ -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 -------------------------------*/
}

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

@ -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 -------------------------------*/
}

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

@ -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 -------------------------------*/
}

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

@ -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);
}
}

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

@ -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);
}
}

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

@ -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);
}
}

529
hutool-core/src/main/java/cn/hutool/core/lang/getter/TypeGetter.java Normal file
View File

@ -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 -------------------------------*/
}

160
hutool-core/src/main/java/cn/hutool/core/map/Dict.java
View File

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

14
hutool-core/src/main/java/cn/hutool/core/map/MapProxy.java
View File

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

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

@ -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);
}

1
hutool-core/src/main/java/cn/hutool/core/text/CharSequenceUtil.java
View File

@ -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-"

10
hutool-core/src/test/java/cn/hutool/core/collection/MapProxyTest.java
View File

@ -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());
}

2
hutool-core/src/test/java/cn/hutool/core/convert/ConvertTest.java
View File

@ -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

59
hutool-core/src/test/java/cn/hutool/core/stream/AbstractEnhancedWrappedStreamTest.java
View File

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

32
hutool-db/src/main/java/cn/hutool/db/Entity.java
View File

@ -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) {
return getStr(field, CharsetUtil.UTF_8);
public String getStr(final String field, final String defaultValue) {
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) {
final Object obj = get(field);
public String getStr(final String field, final Charset charset, final String defaultValue) {
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);
}
/**

8
hutool-db/src/main/java/cn/hutool/db/ds/AbstractDSFactory.java
View File

@ -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 pass = config.getAndRemoveStr(KEY_ALIAS_PASSWORD);
final String user = config.getAndRemove(KEY_ALIAS_USER);
final String pass = config.getAndRemove(KEY_ALIAS_PASSWORD);
return DataSourceWrapper.wrap(createDataSource(url, driver, user, pass, config), driver);
}

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

@ -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);
}

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

@ -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);
}

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

@ -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);
}

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

@ -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);
}

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

@ -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);
}

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

@ -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.setPass(config.getAndRemoveStr(DSFactory.KEY_ALIAS_PASSWORD));
dbConfig.setUser(config.getAndRemove(DSFactory.KEY_ALIAS_USER));
dbConfig.setPass(config.getAndRemove(DSFactory.KEY_ALIAS_PASSWORD));
// 连接池相关信息
dbConfig.setInitialSize(setting.getInt("initialSize", group, 0));
dbConfig.setMinIdle(setting.getInt("minIdle", group, 0));
dbConfig.setMaxActive(setting.getInt("maxActive", group, 8));
dbConfig.setMaxWait(setting.getLong("maxWait", group, 6000L));
dbConfig.setInitialSize(setting.getIntByGroup("initialSize", group, 0));
dbConfig.setMinIdle(setting.getIntByGroup("minIdle", group, 0));
dbConfig.setMaxActive(setting.getIntByGroup("maxActive", group, 8));
dbConfig.setMaxWait(setting.getLongByGroup("maxWait", group, 6000L));
// remarks等特殊配置，since 5.3.8
String connValue;

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

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

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

@ -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);
}

2
hutool-json/src/main/java/cn/hutool/json/JSONConfig.java
View File

@ -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;
}

51
hutool-json/src/main/java/cn/hutool/json/JSONGetter.java
View File

@ -1,11 +1,9 @@
package cn.hutool.json;
import cn.hutool.core.convert.ConvertException;
import cn.hutool.core.lang.getter.OptNullBasicTypeFromObjectGetter;
import cn.hutool.core.lang.getter.TypeGetter;
import cn.hutool.core.util.ObjUtil;
import java.time.LocalDateTime;
import java.util.Date;
import java.lang.reflect.Type;
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) {
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 {
default <T> T get(final K key, final Type type, final T defaultValue) {
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);
}
}

230
hutool-setting/src/main/java/cn/hutool/setting/AbsSetting.java
View File

@ -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.OptNullBasicTypeFromStringGetter;
import cn.hutool.core.lang.getter.GroupedTypeGetter;
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) {
return getStr(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);
public Object getObj(final CharSequence key, final Object defaultValue) {
return ObjUtil.defaultIfNull(getObjByGroup(key, DEFAULT_GROUP), 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) {
final String value = getByGroup(key, group);
public String getByGroupNotEmpty(final String key, final String group, final String defaultValue) {
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) {
return getStrings(key, null);
public String[] getStrs(final String key) {
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) {
String[] value = getStrings(key, null);
public String[] getStrs(final CharSequence key, final String[] defaultValue) {
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) {
return getStrings(key, group, DEFAULT_DELIMITER);
public String[] getStrsByGroup(final CharSequence key, final CharSequence group) {
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) {
final String value = getByGroup(key, group);
public String[] getStrsByGroup(final CharSequence key, final CharSequence group, final CharSequence delimiter) {
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));
}

4
hutool-setting/src/main/java/cn/hutool/setting/GroupedMap.java
View File

@ -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();

86
hutool-setting/src/main/java/cn/hutool/setting/Setting.java
View File

@ -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);
}
/**
* 构造，相对于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);
this.init(ResourceUtil.getResource(configFile), 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) {
return this.groupedMap.get(group, key);
}
/**
* 获取并删除键值对，当指定键对应值非空时，返回并删除这个值，后边的键对应的值不再查找
*
* @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;
}
public Object getObjByGroup(final CharSequence key, final CharSequence group, final Object defaultValue) {
final String result = this.groupedMap.get(group, key);
if (result == null && logIfNull) {
StaticLog.debug("No key [{}] in group [{}] !", key, group);
}
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);
}
/**

285
hutool-setting/src/main/java/cn/hutool/setting/dialect/Props.java
View File

@ -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.OptBasicTypeGetter;
import cn.hutool.core.lang.getter.TypeGetter;
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);
}
/**
* 构造，使用相对于Class文件根目录的相对路径
*
* @param path 相对或绝对路径
* @param charsetName 字符集
*/
public Props(final String path, final String charsetName) {
this(path, CharsetUtil.charset(charsetName));
this(path, null);
}
/**
* 构造，使用相对于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 字符集
*/
public Props(final File propertiesFile, final String charsetName) {
this(propertiesFile, Charset.forName(charsetName));
}
/**
* 构造
*
* @param propertiesFile 配置文件对象
* @param charset 字符集
* @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) {
this(propertiesUrl, StandardCharsets.ISO_8859_1);
}
/**
* 构造，使用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 !");
public Props(final Resource resource, final Charset charset) {
Assert.notNull(resource, "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) {
return getStr(key, null == defaultValue ? null : defaultValue.toString());
}
@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);
public Object getObj(final CharSequence key, final Object defaultValue) {
return ObjUtil.defaultIfNull(getProperty(StrUtil.str(key)), defaultValue);
}
/**

8
hutool-setting/src/test/java/cn/hutool/setting/PropsTest.java
View File

@ -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());

12
hutool-setting/src/test/java/cn/hutool/setting/SettingTest.java
View File

@ -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("root2", setting.getByGroup("user", "group2"));
Assert.assertEquals("root3", setting.getByGroup("user", "group3"));
Assert.assertEquals("root", setting.getStrByGroup("user", "group1"));
Assert.assertEquals("root2", setting.getStrByGroup("user", "group2"));
Assert.assertEquals("root3", setting.getStrByGroup("user", "group3"));
Assert.assertEquals("root4", setting.get("user"));
}

6
hutool-setting/src/test/java/cn/hutool/setting/SettingUtilTest.java
View File

@ -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);
}
}