整个工具的代码都在Gitee或者Github地址内
gitee：solomon-parent: 这个项目主要是总结了工作上遇到的问题以及学习一些框架用于整合例如:rabbitMq、reids、Mqtt、S3协议的文件服务器、mongodb
github：https://github.com/ZeroNing/solomon-parent
需要引入的JAR包
<dependencies>
<!-- 校验注解所有需要jar包 开始 -->
<dependency>
<groupId>javax.validation</groupId>
<artifactId>validation-api</artifactId>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
</dependency>
<!-- 校验注解所有需要jar包 结束 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-json</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-autoconfigure</artifactId>
</dependency>
<dependency>
<groupId>com.steven</groupId>
<artifactId>solomon-constant</artifactId>
<version>1.0</version>
</dependency>
<dependency>
<groupId>commons-codec</groupId>
<artifactId>commons-codec</artifactId>
</dependency>
<dependency>
<groupId>commons-lang</groupId>
<artifactId>commons-lang</artifactId>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-collections4</artifactId>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-crypto</artifactId>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-core</artifactId>
<version>${hutool.version}</version>
</dependency>
</dependencies>枚举国际化注解
/**
* 枚举序列化返回参数
* @author huangweihua
*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@JacksonAnnotationsInside
@JsonSerialize(using = EnumSerializer.class)
public @interface JsonEnum {
Class<? extends Enum> enumClass();
/**
* 调用enumClass的Get方法，然后在返回字段后面添加后缀
*/
String[] methodNames() default {BaseMethodNameEnum.DESCRIPTION};
/**
* 如果自定义字段返回,则可以增加此字段返回
*/
String fieldName() default "";
/**
* 是否输出这个结果
* @return
*/
boolean ignore() default true;
}枚举序列化工具
序列化和反序列化LocalDateTime其中包括时区转换（通过RequestHeaderHolder获取时区，不存在，默认服务器时区或电脑时区）
public class CustomLocalDateTimeDeserializer extends JsonDeserializer<LocalDateTime> {
private DateTimeFormatter formatter;
public CustomLocalDateTimeDeserializer(DateTimeFormatter formatter) {
super();
this.formatter = formatter;
}
@Override
public LocalDateTime deserialize(JsonParser parser, DeserializationContext context)
throws IOException {
return DateTimeUtils.convertLocalDateTime(LocalDateTime.parse(parser.getText(), formatter),
ZoneId.of(RequestHeaderHolder.getTimeZone()), ZoneId.systemDefault());
}
}public class CustomLocalDateTimeSerializer extends JsonSerializer<LocalDateTime> {
private DateTimeFormatter formatter;
public CustomLocalDateTimeSerializer(DateTimeFormatter formatter) {
super();
this.formatter = formatter;
}
@Override
public void serialize(LocalDateTime value, JsonGenerator generator, SerializerProvider provider) throws IOException {
generator.writeString(DateTimeUtils.convertLocalDateTime(value, ZoneId.systemDefault(), ZoneId.of(RequestHeaderHolder.getTimeZone())).format(formatter));
}
}jackJson配置类
@Configuration
public class JacksonObjectMapper extends ObjectMapper {
public JacksonObjectMapper(){
super();
JavaTimeModule javaTimeModule = new JavaTimeModule();
/** 序列化配置,针对java8 时间 **/
javaTimeModule.addSerializer(LocalDateTime.class, new CustomLocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS")));
javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
javaTimeModule.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern("HH:mm:ss")));
javaTimeModule.addSerializer(Date.class,new DateSerializer(false,new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS")));
/** 反序列化配置,针对java8 时间 **/
javaTimeModule.addDeserializer(LocalDateTime.class, new CustomLocalDateTimeDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS")));
javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
javaTimeModule.addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern("HH:mm:ss")));
javaTimeModule.addDeserializer(Date.class,new DateDeserializers.DateDeserializer());
SimpleModule simpleModule = new SimpleModule();
simpleModule.addSerializer(Long.class, ToStringSerializer.instance);
simpleModule.addSerializer(Long.TYPE, ToStringSerializer.instance);
simpleModule.addSerializer(BigInteger.class, ToStringSerializer.instance);
this.registerModule(javaTimeModule).registerModule(new ParameterNamesModule()).registerModule(simpleModule);
this.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
this.disable(DeserializationFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE);
this.registerModule(javaTimeModule).registerModule(new ParameterNamesModule()).registerModule(simpleModule);
//序列化的时候序列对象的所有属性
this.setSerializationInclusion(Include.ALWAYS);
//反序列化的时候如果多了其他属性,不抛出异常
this.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
}
}枚举国际化序列化方法
public class EnumSerializer extends JsonSerializer<String> implements ContextualSerializer {
private Logger logger = LoggerUtils.logger(getClass());
private Class<? extends Enum> enumClass;
private String prefix;
private String[] methodNames;
private String fieldName;
public EnumSerializer() {
super();
}
public EnumSerializer(Class<? extends Enum> enumClass,String prefix,String[] methodNames,String fieldName) {
this.enumClass = enumClass;
this.prefix = prefix;
this.methodNames = methodNames;
this.fieldName = fieldName;
}
@Override
public void serialize(String o, JsonGenerator jsonGenerator, SerializerProvider serializerProvider)
throws IOException {
jsonGenerator.writeString(o);
try {
Enum enums = EnumUtils.codeOf(enumClass,o);
if(ValidateUtils.isEmpty(enums)){
logger.info("EnumSerializer 转换枚举为空,值:{},类名:{}",o,enumClass.getName());
return;
}
for (String methodName : methodNames) {
String value = (String) enumClass.getMethod(methodName).invoke(enums);
if(ValidateUtils.isEmpty(fieldName)){
jsonGenerator.writeStringField(new StringBuilder(prefix).append(methodName).toString(), value);
} else {
jsonGenerator.writeStringField(fieldName,value);
}
}
} catch (Throwable e) {
logger.info("EnumSerializer 转换失败,值:{},枚举类为:{},调用方法名为:{}报错异常为 e:{}",o,enumClass.getName(),methodNames.toString(),e);
return;
}
}
@Override
public JsonSerializer<?> createContextual(SerializerProvider serializerProvider, BeanProperty beanProperty)
throws JsonMappingException {
if (ValidateUtils.isEmpty(beanProperty)) {
return serializerProvider.findNullValueSerializer(beanProperty);
}
if (!Objects.equals(beanProperty.getType().getRawClass(), String.class)) {
return serializerProvider.findValueSerializer(beanProperty.getType(), beanProperty);
}
JsonEnum enumLabel = beanProperty.getAnnotation(JsonEnum.class);
if (ValidateUtils.isEmpty(enumLabel) || !enumLabel.ignore()) {
return serializerProvider.findValueSerializer(beanProperty.getType(), beanProperty);
}
return new EnumSerializer(enumLabel.enumClass(),beanProperty.getName(),enumLabel.methodNames(),enumLabel.fieldName());
}
}fastJson枚举国际化序列化方法
public class FastJsonAfterFilter extends AfterFilter {
private Logger logger = LoggerUtils.logger(getClass());
@Override
public void writeAfter(Object o) {
Class clazz = o.getClass();
List<Field> fields = new ArrayList<>();
Arrays.asList(o.getClass().getDeclaredFields()).forEach(field -> {
Optional.ofNullable(field).filter(a -> a.isAnnotationPresent(JsonEnum.class)).ifPresent(a -> fields.add(a));
});
if(ValidateUtils.isEmpty(fields)){
return;
}
for (Field field : fields) {
try {
JsonEnum fastJsonEnum = field.getAnnotation(JsonEnum.class);
if(!fastJsonEnum.ignore()){
continue;
}
Method method = clazz.getMethod("get" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1));
Class<? extends Enum> enumClass = fastJsonEnum.enumClass();
String enumValue = (String) method.invoke(o);
Enum enums = EnumUtils.codeOf(enumClass, enumValue);
if(ValidateUtils.isEmpty(enums)){
logger.info("fastJson 转换枚举为空,值:{},类名:{}",enumValue,enumClass.getName());
continue;
}
String[] methodNames = fastJsonEnum.methodNames();
String prefix = field.getName();
for(String methodName: methodNames){
String value = (String) enumClass.getMethod(methodName).invoke(enums);
if(ValidateUtils.isEmpty(fastJsonEnum.fieldName())){
super.writeKeyValue(new StringBuilder(prefix).append(methodName).toString(), value);
} else {
super.writeKeyValue(fastJsonEnum.fieldName(),value);
}
}
} catch (Throwable e) {
logger.info("fastJson 转义注解失败,失败异常为 e:{}",e);
// throw new BaseException(BaseExceptionCode.BASE_EXCEPTION_CODE);
}
}
}
}FastJson和JackJson工具方法
public class FastJsonUtils {
/**
* 转换json
* @param result
* @return
* @throws JsonProcessingException
*/
public static String formatJsonByFilter(Object result, SerializeFilter... filter){
return JSONObject.toJSONString(result,filter);
}
/**
* 转换json
* @param result
* @return
* @throws JsonProcessingException
*/
public static byte[] formatBytesByFilter(Object result, SerializeFilter... filter){
return JSONObject.toJSONBytes(result,filter);
}
/**
* 转换对象
*/
public static <T> T conversionClass(String s, Class<T> t) throws IOException {
return JSONObject.parseObject(s,t);
}
/**
* 转换数组对象
*/
public static <T> T conversionClassList(String s,String arrayString, TypeReference<T> jsonTypeReference) throws IOException {
String json = s;
if(ValidateUtils.isNotEmpty(arrayString)){
JSONObject jsonObject = JSON.parseObject(s);
JSONArray jsonArray = jsonObject.getJSONArray(arrayString);
json = jsonArray.toJSONString();
}
return JSONObject.parseObject(json, jsonTypeReference);
}
/**
* 获取jsonObject对象
*/
public static JSONObject conversionJsonArray(String s){
return JSON.parseObject(s);
}
/**
* 获取json字符串节点数据
* @param s json
* @param arrayString 节点数据key
*/
public static JSONArray conversionJsonArray(String s,String arrayString){
JSONObject jsonObject = conversionJsonArray(s);
return jsonObject.getJSONArray(arrayString);
}
/**
* 获取json字符串节点数据
* @param jsonObject 获取jsonObject对象
* @param arrayString 节点数据key
*/
public static JSONArray conversionJsonArray(JSONObject jsonObject,String arrayString){
return jsonObject.getJSONArray(arrayString);
}
}public class JackJsonUtils {
private static final Logger logger = LoggerUtils.logger(JackJsonUtils.class);
private static final JacksonObjectMapper mapper = SpringUtil.getBean(JacksonObjectMapper.class);
public static <T> T convertValue(Object obj,Class<T> clazz){
return convertValue(obj, clazz,false);
}
public static <T> T convertValue(Object obj,Class<T> clazz,boolean isIgnoreNull){
if(isIgnoreNull){
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
}
return mapper.convertValue(obj, clazz);
}
/**
* 转换对象
*/
public static <T> T conversionClass(String json, Class<T> t) throws IOException {
return mapper.readValue(json, t);
}
/**
* 转换数组对象
*/
public static <T> List<T> conversionClassList(String json, Class<T> clazz) throws IOException {
//忽略多余属性
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
CollectionType listType = mapper.getTypeFactory().constructCollectionType(ArrayList.class, clazz);
return mapper.readValue(json, listType);
}
/**
* 转换json
*
* @param result
* @return
* @throws JsonProcessingException
*/
public static String formatJsonByFilter(Object result){
return formatJsonByFilter(result, null);
}
/**
* 转换json
*
* @param result
* @param filter
* @return
* @throws JsonProcessingException
*/
public static String formatJsonByFilter(Object result, Class<?> filter) {
try {
return ValidateUtils.isEmpty(filter) ? mapper.writeValueAsString(result) : mapper.writerWithView(filter).writeValueAsString(result);
} catch (Throwable e) {
// logger.error("转换Json出现异常:{}",e);
return "";
}
}
}
Lambda表达式基础工具
public class Lambda {
/**
* 转list
*
* @param list 数据集合
* @param predicate 条件筛选数据
* @param func 需要的字段
*/
public static <T, S> List<T> toList(Collection<S> list, Predicate<S> predicate, Function<S, T> func,boolean isParallelStream) {
if (ValidateUtils.isEmpty(list)) {
return new ArrayList<>();
}
Stream<S> stream = isParallelStream ? list.parallelStream() : list.stream();
if(ValidateUtils.isNotEmpty(predicate)){
stream = stream.filter(predicate);
}
return stream.map(func).collect(Collectors.toList());
}
/**
* 转list
*
* @param list 数据集合
* @param func 需要的字段
*/
public static <T, S> List<T> toList(Collection<S> list, Function<S, T> func,boolean isParallelStream) {
return toList(list,null,func,isParallelStream);
}
/**
* 转list
*
* @param list 数据集合
* @param func 需要的字段
*/
public static <T, S> List<T> toList(Collection<S> list, Function<S, T> func) {
return toList(list,null,func,false);
}
/**
* 转set
*
* @param list 数据集合
* @param predicate 条件筛选数据
* @param func 需要的字段
*/
public static <T, S> Set<T> toSet(Collection<S> list, Predicate<S> predicate, Function<S, T> func,boolean isParallelStream) {
if (ValidateUtils.isEmpty(list)) {
return new HashSet<>();
}
Stream<S> stream = isParallelStream ? list.parallelStream() : list.stream();
if(ValidateUtils.isNotEmpty(predicate)){
stream = stream.filter(predicate);
}
return stream.map(func).collect(Collectors.toSet());
}
/**
* 转set
*
* @param list 数据集合
* @param func 需要的字段
*/
public static <T, S> Set<T> toSet(Collection<S> list, Function<S, T> func,boolean isParallelStream) {
return toSet(list,null,func,isParallelStream);
}
/**
* 转set
*
* @param list 数据集合
* @param func 需要的字段
*/
public static <T, S> Set<T> toSet(Collection<S> list, Function<S, T> func) {
return toSet(list,null,func,false);
}
/**
* 转map
*
* @param list 数据集合
* @param keyFunc 需要的字段
*/
public static <K, T> Map<K, T> toMap(Collection<T> list, Function<T, K> keyFunc,boolean isParallelStream) {
if (ValidateUtils.isEmpty(list)) {
return new HashMap<>();
}
Stream<T> stream = isParallelStream ? list.parallelStream() : list.stream();
return stream.collect(Collectors.toMap(keyFunc, Function.identity(), (key1, key2) -> key2));
}
/**
* 转map
*
* @param list 数据集合
* @param keyFunc 需要的字段
*/
public static <K, T> Map<K, T> toMap(Collection<T> list, Function<T, K> keyFunc) {
return toMap(list,keyFunc,false);
}
/**
* 转map
*
* @param list 数据集合
* @param predicate 条件筛选数据
* @param keyFunc 需要的字段
*/
public static <K, T> Map<K, T> toMapPredicate(Collection<T> list, Predicate<T> predicate, Function<T, K> keyFunc) {
return toMapPredicate(list,predicate,keyFunc,false);
}
/**
* 转map
*
* @param list 数据集合
* @param predicate 条件筛选数据
* @param keyFunc 需要的字段
*/
public static <K, T> Map<K, T> toMapPredicate(Collection<T> list, Predicate<T> predicate, Function<T, K> keyFunc,boolean isParallelStream) {
if (ValidateUtils.isEmpty(list)) {
return new HashMap<>();
}
Stream<T> stream = isParallelStream ? list.parallelStream() : list.stream();
if(ValidateUtils.isNotEmpty(predicate)){
stream = stream.filter(predicate);
}
return stream.collect(Collectors.toMap(keyFunc, Function.identity(), (key1, key2) -> key2));
}
/**
* 转map
*
* @param list 数据集合
* @param predicate 条件筛选数据
* @param keyFunc 需要的字段
* @param valFunc 需要的字段
*/
public static <K, V, T> Map<K, V> toMapPredicate(Collection<T> list, Predicate<T> predicate, Function<T, K> keyFunc,
Function<T, V> valFunc,boolean isParallelStream) {
if (ValidateUtils.isEmpty(list)) {
return new HashMap<>();
}
Stream<T> stream = isParallelStream ? list.parallelStream() : list.stream();
if(ValidateUtils.isNotEmpty(predicate)){
stream = stream.filter(predicate);
}
return stream.collect(Collectors.toMap(keyFunc, valFunc, (key1, key2) -> key2));
}
/**
* 转map
*
* @param list 数据集合
* @param predicate 条件筛选数据
* @param keyFunc 需要的字段
* @param valFunc 需要的字段
*/
public static <K, V, T> Map<K, V> toMapPredicate(Collection<T> list, Predicate<T> predicate, Function<T, K> keyFunc,
Function<T, V> valFunc) {
return toMapPredicate(list,predicate,keyFunc,valFunc,false);
}
/**
* 转map
*
* @param list 数据集合
* @param keyFunc 需要的字段
* @param valFunc 需要的字段
*/
public static <K, V, T> Map<K, V> toMap(Collection<T> list, Function<T, K> keyFunc, Function<T, V> valFunc,boolean isParallelStream) {
if (ValidateUtils.isEmpty(list)) {
return new HashMap<>();
}
Stream<T> stream = isParallelStream ? list.parallelStream() : list.stream();
return stream.collect(Collectors.toMap(keyFunc, valFunc, (key1, key2) -> key2));
}
/**
* 转map
*
* @param list 数据集合
* @param keyFunc 需要的字段
* @param valFunc 需要的字段
*/
public static <K, V, T> Map<K, V> toMap(Collection<T> list, Function<T, K> keyFunc, Function<T, V> valFunc) {
return toMap(list,keyFunc,valFunc,false);
}
/**
* 分组
*
* @param list 数据集合
* @param predicate 条件筛选数据
* @param groupByFunc 分组需要字段
*/
public static <K, T> Map<K, List<T>> groupBy(Collection<T> list, Predicate<T> predicate, Function<T, K> groupByFunc,boolean isParallelStream) {
if (ValidateUtils.isEmpty(list)) {
return new HashMap<>();
}
Stream<T> stream = isParallelStream ? list.parallelStream() : list.stream();
if(ValidateUtils.isNotEmpty(predicate)){
stream = stream.filter(predicate);
}
return stream.collect(Collectors.groupingBy(groupByFunc));
}
/**
* 分组
*
* @param list 数据集合
* @param predicate 条件筛选数据
* @param groupByFunc 分组需要字段
*/
public static <K, T> Map<K, List<T>> groupBy(Collection<T> list, Predicate<T> predicate, Function<T, K> groupByFunc) {
return groupBy(list,predicate,groupByFunc,false);
}
/**
* 分组
*
* @param list 数据集合
* @param groupByFunc 分组需要字段
*/
public static <K, T> Map<K, List<T>> groupBy(Collection<T> list, Function<T, K> groupByFunc) {
if (ValidateUtils.isEmpty(list)) {
return new HashMap<>();
}
return groupBy(list,null,groupByFunc,false);
}
/**
* 汇总
*
* @param list 数据集合
* ram func 分组汇总相加的字段
*/
public static <T> Integer sum(Collection<T> list, ToIntFunction<T> func) {
return sum(list,null,func,false);
}
/**
* 汇总
*
* @param list 数据集合
* ram func 分组汇总相加的字段
*/
public static <T> Integer sum(Collection<T> list, ToIntFunction<T> func,boolean isParallelStream) {
return sum(list,null,func,isParallelStream);
}
/**
* 汇总
*
* @param list 数据集合
* @param predicate 条件筛选数据
* @param func 分组汇总相加的字段
*/
public static <T> Integer sum(Collection<T> list, Predicate<T> predicate, ToIntFunction<T> func,boolean isParallelStream) {
Stream<T> stream = isParallelStream ? list.parallelStream() : list.stream();
if(ValidateUtils.isNotEmpty(predicate)){
stream = stream.filter(predicate);
}
return stream.mapToInt(func).sum();
}
/**
* 汇总
*
* @param list 数据集合
* @param predicate 条件筛选数据
* @param func 分组汇总相加的字段
*/
public static <T> Integer sum(Collection<T> list, Predicate<T> predicate, ToIntFunction<T> func) {
return sum(list,predicate,func,false);
}
/**
* 汇总
*
* @param list 数据集合
* @param func 分组汇总相加的字段
*/
public static <T> Long sum(Collection<T> list, ToLongFunction<T> func) {
return sum(list,null,func,false);
}
/**
* 汇总
*
* @param list 数据集合
* @param func 分组汇总相加的字段
*/
public static <T> Long sum(Collection<T> list, ToLongFunction<T> func,boolean isParallelStream) {
return sum(list,null,func,isParallelStream);
}
/**
* 汇总
*
* @param list 数据集合
* @param predicate 条件筛选数据
* @param func 分组汇总相加的字段
*/
public static <T> Long sum(Collection<T> list, Predicate<T> predicate, ToLongFunction<T> func,boolean isParallelStream) {
Stream<T> stream = isParallelStream ? list.parallelStream() : list.stream();
if(ValidateUtils.isNotEmpty(predicate)){
stream = stream.filter(predicate);
}
return stream.mapToLong(func).sum();
}
/**
* 汇总
*
* @param list 数据集合
* @param predicate 条件筛选数据
* @param func 分组汇总相加的字段
*/
public static <T> Long sum(Collection<T> list, Predicate<T> predicate, ToLongFunction<T> func) {
return sum(list,predicate,func,false);
}
/**
* 汇总
*
* @param list 数据集合
* @param func 分组汇总相加的字段
*/
public static <T, K> Double sum(Collection<T> list, ToDoubleFunction<T> func) {
return sum(list,func,false);
}
/**
* 汇总
*
* @param list 数据集合
* @param func 分组汇总相加的字段
*/
public static <T, K> Double sum(Collection<T> list, ToDoubleFunction<T> func,boolean isParallelStream) {
return sum(list,func,isParallelStream);
}
/**
* 汇总
*
* @param list 数据集合
* @param predicate 条件筛选数据
* @param func 分组汇总相加的字段
*/
public static <T> Double sum(Collection<T> list, Predicate<T> predicate, ToDoubleFunction<T> func,boolean isParallelStream) {
Stream<T> stream = isParallelStream ? list.parallelStream() : list.stream();
if(ValidateUtils.isNotEmpty(predicate)){
stream = stream.filter(predicate);
}
return stream.mapToDouble(func).sum();
}
/**
* 汇总
*
* @param list 数据集合
* @param predicate 条件筛选数据
* @param func 分组汇总相加的字段
*/
public static <T> Double sum(Collection<T> list, Predicate<T> predicate, ToDoubleFunction<T> func) {
return sum(list,predicate,func,false);
}
/**
* 分组统计
*
* @param list 数据集合
* @param groupByFunc 分组统计的字段
*/
public static <K, T> Map<K, Long> groupByCount(Collection<T> list, Function<T, K> groupByFunc) {
if (ValidateUtils.isEmpty(list)) {
return new HashMap<>();
}
return list.stream().collect(Collectors.groupingBy(groupByFunc, Collectors.counting()));
}
/**
* 分组统计
*
* @param list 数据集合
* @param predicate 条件筛选数据
* @param groupByFunc 分组统计的字段
*/
public static <K, T> Map<K, Long> groupByCount(Collection<T> list, Function<T, K> groupByFunc,
Predicate<T> predicate) {
if (ValidateUtils.isEmpty(list)) {
return new HashMap<>();
}
return list.stream().filter(predicate).collect(Collectors.groupingBy(groupByFunc, Collectors.counting()));
}
/**
* 分组汇总
*
* @param list 数据集合
* @param groupByFunc 分组字段
* @param sumFunc 分组汇总相加的字段
*/
public static <K, T> Map<K, Integer> groupBySum(Collection<T> list, Function<T, K> groupByFunc,
ToIntFunction<T> sumFunc) {
if (ValidateUtils.isEmpty(list)) {
return new HashMap<>();
}
return list.stream().collect(Collectors.groupingBy(groupByFunc, Collectors.summingInt(sumFunc)));
}
/**
* 分组汇总
*
* @param list 数据集合
* @param groupByFunc 分组字段
* @param predicate 条件筛选数据
* @param sumFunc 分组汇总相加的字段
*/
public static <K, T> Map<K, Integer> groupBySum(Collection<T> list, Function<T, K> groupByFunc,
Predicate<T> predicate, ToIntFunction<T> sumFunc) {
if (ValidateUtils.isEmpty(list)) {
return new HashMap<>();
}
return list.stream().filter(predicate).collect(Collectors.groupingBy(groupByFunc, Collectors.summingInt(sumFunc)));
}
/**
* 分组汇总
*
* @param list 数据集合
* @param groupByFunc 分组字段
* @param sumFunc 分组汇总相加的字段
*/
public static <K, T> Map<K, Long> groupBySum(Collection<T> list, Function<T, K> groupByFunc,
ToLongFunction<T> sumFunc) {
if (ValidateUtils.isEmpty(list)) {
return new HashMap<>();
}
return list.stream().collect(Collectors.groupingBy(groupByFunc, Collectors.summingLong(sumFunc)));
}
/**
* 分组汇总
*
* @param list 数据集合
* @param groupByFunc 分组字段
* @param predicate 条件筛选数据
* @param sumFunc 分组汇总相加的字段
*/
public static <K, T> Map<K, Long> groupBySum(Collection<T> list, Function<T, K> groupByFunc, Predicate<T> predicate,
ToLongFunction<T> sumFunc) {
if (ValidateUtils.isEmpty(list)) {
return new HashMap<>();
}
return list.stream().filter(predicate).collect(Collectors.groupingBy(groupByFunc, Collectors.summingLong(sumFunc)));
}
/**
* 分组汇总
*
* @param list 数据集合
* @param groupByFunc 分组字段
* @param sumFunc 分组汇总相加的字段
*/
public static <K, T> Map<K, Double> groupBySum(Collection<T> list, Function<T, K> groupByFunc,
ToDoubleFunction<T> sumFunc) {
if (ValidateUtils.isEmpty(list)) {
return new HashMap<>();
}
return list.stream().collect(Collectors.groupingBy(groupByFunc, Collectors.summingDouble(sumFunc)));
}
/**
* 分组汇总
*
* @param list 数据集合
* @param groupByFunc 分组字段
* @param predicate 条件筛选数据
* @param sumFunc 分组汇总相加的字段
*/
public static <K, T> Map<K, Double> groupBySum(Collection<T> list, Function<T, K> groupByFunc, Predicate<T> predicate,
ToDoubleFunction<T> sumFunc) {
if (ValidateUtils.isEmpty(list)) {
return new HashMap<>();
}
return list.stream().filter(predicate)
.collect(Collectors.groupingBy(groupByFunc, Collectors.summingDouble(sumFunc)));
}
/**
* 交叉集
*
* @param sourceList 数据集合
* @param predicate 条件筛选数据
*/
public static <T> List<T> cross(Collection<T> sourceList, Predicate<T> predicate) {
if (ValidateUtils.isEmpty(sourceList)) {
return new ArrayList<>();
}
return sourceList.stream().filter(predicate).collect(Collectors.toList());
}
/**
* 找出最大值
*
* @param list 数据集合
* ram func 分组汇总相加的字段
*/
public static <S> S max(Collection<S> list, Comparator<? super S> comparator) {
if(ValidateUtils.isEmpty(list)){
return null;
}
return list.stream().max(comparator).get();
}
/**
* 找出最大值
*
* @param list 数据集合
* ram func 分组汇总相加的字段
*/
public static <T> Integer max(Collection<T> list, ToIntFunction<T> func) {
if(ValidateUtils.isEmpty(list)){
return null;
}
return list.stream().mapToInt(func).max().getAsInt();
}
/**
* 找出最大值
*
* @param list 数据集合
* @param predicate 条件筛选数据
* @param func 分组汇总相加的字段
*/
public static <T> Integer max(Collection<T> list, Predicate<T> predicate, ToIntFunction<T> func) {
if(ValidateUtils.isEmpty(list)){
return null;
}
return list.stream().filter(predicate).mapToInt(func).max().getAsInt();
}
/**
* 找出最大值
*
* @param list 数据集合
* @param func 分组汇总相加的字段
*/
public static <T> Long max(Collection<T> list, ToLongFunction<T> func) {
if(ValidateUtils.isEmpty(list)){
return null;
}
return list.stream().mapToLong(func).max().getAsLong();
}
/**
* 找出最大值
*
* @param list 数据集合
* @param predicate 条件筛选数据
* @param func 分组汇总相加的字段
*/
public static <T> Long max(Collection<T> list, Predicate<T> predicate, ToLongFunction<T> func) {
if(ValidateUtils.isEmpty(list)){
return null;
}
return list.stream().filter(predicate).mapToLong(func).max().getAsLong();
}
/**
* 找出最大值
*
* @param list 数据集合
* @param func 分组汇总相加的字段
*/
public static <T, K> Double max(Collection<T> list, ToDoubleFunction<T> func) {
if(ValidateUtils.isEmpty(list)){
return null;
}
return list.stream().mapToDouble(func).max().getAsDouble();
}
/**
* 找出最大值
*
* @param list 数据集合
* @param predicate 条件筛选数据
* @param func 分组汇总相加的字段
*/
public static <T> Double max(Collection<T> list, Predicate<T> predicate, ToDoubleFunction<T> func) {
if(ValidateUtils.isEmpty(list)){
return null;
}
return list.stream().filter(predicate).mapToDouble(func).max().getAsDouble();
}
/**
* 找出最大值
*
* @param list 数据集合
* ram func 分组汇总相加的字段
*/
public static <S> S min(Collection<S> list, Comparator<? super S> comparator) {
if(ValidateUtils.isEmpty(list)){
return null;
}
return list.stream().min(comparator).get();
}
/**
* 找出最小值
*
* @param list 数据集合
* ram func 分组汇总相加的字段
*/
public static <T> Integer min(Collection<T> list, ToIntFunction<T> func) {
if(ValidateUtils.isEmpty(list)){
return null;
}
return list.stream().mapToInt(func).min().getAsInt();
}
/**
* 找出最小值
*
* @param list 数据集合
* @param predicate 条件筛选数据
* @param func 分组汇总相加的字段
*/
public static <T> Integer min(Collection<T> list, Predicate<T> predicate, ToIntFunction<T> func) {
if(ValidateUtils.isEmpty(list)){
return null;
}
return list.stream().filter(predicate).mapToInt(func).min().getAsInt();
}
/**
* 找出最小值
*
* @param list 数据集合
* @param func 分组汇总相加的字段
*/
public static <T> Long min(Collection<T> list, ToLongFunction<T> func) {
if(ValidateUtils.isEmpty(list)){
return null;
}
return list.stream().mapToLong(func).min().getAsLong();
}
/**
* 找出最小值
*
* @param list 数据集合
* @param predicate 条件筛选数据
* @param func 分组汇总相加的字段
*/
public static <T> Long min(Collection<T> list, Predicate<T> predicate, ToLongFunction<T> func) {
if(ValidateUtils.isEmpty(list)){
return null;
}
return list.stream().filter(predicate).mapToLong(func).min().getAsLong();
}
/**
* 找出最小值
*
* @param list 数据集合
* @param func 分组汇总相加的字段
*/
public static <T, K> Double min(Collection<T> list, ToDoubleFunction<T> func) {
if(ValidateUtils.isEmpty(list)){
return null;
}
return list.stream().mapToDouble(func).min().getAsDouble();
}
/**
* 找出最小值
*
* @param list 数据集合
* @param predicate 条件筛选数据
* @param func 分组汇总相加的字段
*/
public static <T> Double min(Collection<T> list, Predicate<T> predicate, ToDoubleFunction<T> func) {
if(ValidateUtils.isEmpty(list)){
return null;
}
return list.stream().filter(predicate).mapToDouble(func).min().getAsDouble();
}
/**
* 平均值
*
* @param list 数据集合
* ram func 分组汇总相加的字段
*/
public static <T> Double average(Collection<T> list, ToIntFunction<T> func) {
if(ValidateUtils.isEmpty(list)){
return null;
}
return list.stream().mapToInt(func).average().getAsDouble();
}
/**
* 平均值
*
* @param list 数据集合
* @param predicate 条件筛选数据
* @param func 分组汇总相加的字段
*/
public static <T> Double average(Collection<T> list, Predicate<T> predicate, ToIntFunction<T> func) {
if(ValidateUtils.isEmpty(list)){
return null;
}
return list.stream().filter(predicate).mapToInt(func).average().getAsDouble();
}
/**
* 平均值
*
* @param list 数据集合
* @param func 分组汇总相加的字段
*/
public static <T> Double average(Collection<T> list, ToLongFunction<T> func) {
if(ValidateUtils.isEmpty(list)){
return null;
}
return list.stream().mapToLong(func).average().getAsDouble();
}
/**
* 平均值
*
* @param list 数据集合
* @param predicate 条件筛选数据
* @param func 分组汇总相加的字段
*/
public static <T> Double average(Collection<T> list, Predicate<T> predicate, ToLongFunction<T> func) {
if(ValidateUtils.isEmpty(list)){
return null;
}
return list.stream().filter(predicate).mapToLong(func).average().getAsDouble();
}
/**
* 平均值
*
* @param list 数据集合
* @param func 分组汇总相加的字段
*/
public static <T, K> Double average(Collection<T> list, ToDoubleFunction<T> func) {
if(ValidateUtils.isEmpty(list)){
return null;
}
return list.stream().mapToDouble(func).average().getAsDouble();
}
/**
* 平均值
*
* @param list 数据集合
* @param predicate 条件筛选数据
* @param func 分组汇总相加的字段
*/
public static <T> Double average(Collection<T> list, Predicate<T> predicate, ToDoubleFunction<T> func) {
if(ValidateUtils.isEmpty(list)){
return null;
}
return list.stream().filter(predicate).mapToDouble(func).average().getAsDouble();
}
/**
* 排序
*
* @param list 数据集合
* @param comparator 条件排序(Comparator.comparing)
*/
public static <T> List<T> sort(Collection<T> list, Comparator<? super T> comparator) {
if(ValidateUtils.isEmpty(list)){
return new ArrayList<>();
}
return list.stream().sorted(comparator).collect(Collectors.toList());
}
/**
* 获取各种汇总数据
*
* @param list 数据集合
* ram func 分组汇总相加的字段
*/
public static <T> IntSummaryStatistics summaryStatistics(Collection<T> list, ToIntFunction<T> func) {
if(ValidateUtils.isEmpty(list)){
return new IntSummaryStatistics();
}
return list.stream().mapToInt(func).summaryStatistics();
}
/**
* 获取各种汇总数据
*
* @param list 数据集合
* @param predicate 条件筛选数据
* @param func 分组汇总相加的字段
*/
public static <T> IntSummaryStatistics summaryStatistics(Collection<T> list, Predicate<T> predicate,
ToIntFunction<T> func) {
if(ValidateUtils.isEmpty(list)){
return new IntSummaryStatistics();
}
return list.stream().filter(predicate).mapToInt(func).summaryStatistics();
}
/**
* 获取各种汇总数据
*
* @param list 数据集合
* @param func 分组汇总相加的字段
*/
public static <T> LongSummaryStatistics summaryStatistics(Collection<T> list, ToLongFunction<T> func) {
if(ValidateUtils.isEmpty(list)){
return new LongSummaryStatistics();
}
return list.stream().mapToLong(func).summaryStatistics();
}
/**
* 获取各种汇总数据
*
* @param list 数据集合
* @param predicate 条件筛选数据
* @param func 分组汇总相加的字段
*/
public static <T> LongSummaryStatistics summaryStatistics(Collection<T> list, Predicate<T> predicate,
ToLongFunction<T> func) {
if(ValidateUtils.isEmpty(list)){
return new LongSummaryStatistics();
}
return list.stream().filter(predicate).mapToLong(func).summaryStatistics();
}
/**
* 获取各种汇总数据
*
* @param list 数据集合
* @param func 分组汇总相加的字段
*/
public static <T> DoubleSummaryStatistics summaryStatistics(Collection<T> list, ToDoubleFunction<T> func) {
if(ValidateUtils.isEmpty(list)){
return new DoubleSummaryStatistics();
}
return list.stream().mapToDouble(func).summaryStatistics();
}
/**
* 获取各种汇总数据
*
* @param list 数据集合
* @param predicate 条件筛选数据
* @param func 分组汇总相加的字段
*/
public static <T> DoubleSummaryStatistics summaryStatistics(Collection<T> list, Predicate<T> predicate,
ToDoubleFunction<T> func) {
if(ValidateUtils.isEmpty(list)){
return new DoubleSummaryStatistics();
}
return list.stream().filter(predicate).mapToDouble(func).summaryStatistics();
}
/**
* 去重
* @param list 数据集合
* @param func 需要的字段
*/
public static <T,S> List<S> distinct(List<T> list, Function<T, S> func){
if(ValidateUtils.isEmpty(list)){
return new ArrayList<>();
}
return list.stream().map(func).distinct().collect(Collectors.toList());
}
/**
* 匹配 判断的条件里，任意一个元素成功，返回true
*
* @param list 数据集合
* @param predicate 条件筛选数据
*/
public <T> boolean anyMatch(List<T> list,Predicate<T> predicate){
if(ValidateUtils.isEmpty(list)){
return false;
}
return list.stream().anyMatch(predicate);
}
/**
* 匹配 判断条件里的元素，所有的都是，返回true
*
* @param list 数据集合
* @param predicate 条件筛选数据
*/
public static <T> boolean allMatch(List<T> list,Predicate<T> predicate){
if(ValidateUtils.isEmpty(list)){
return false;
}
return list.stream().allMatch(predicate);
}
/**
* 匹配 noneMatch跟allMatch相反，判断条件里的元素，所有的都不是，返回true
*
* @param list 数据集合
* @param predicate 条件筛选数据
*/
public static <T> boolean noneMatch(List<T> list,Predicate<T> predicate){
if(ValidateUtils.isEmpty(list)){
return false;
}
return list.stream().noneMatch(predicate);
}
/**
* 找出重复记录
* @param list 数据集合
* @param groupByFunc 分组条件
*/
public static <K, T> List<K> repeat(List<T> list, Function<T, K> groupByFunc){
if(ValidateUtils.isEmpty(list)){
return new ArrayList<>();
}
Map<K, List<T>> groupByMap = groupBy(list,groupByFunc);
return groupByMap.entrySet().stream().filter(entry -> entry.getValue().size() > 1).map(entry-> entry.getKey()).collect(Collectors.toList());
}
}Spring上下文工具类
@Configuration
@Order(1)
public class SpringUtil implements ApplicationContextAware {
private static ApplicationContext context;
public SpringUtil(ApplicationContext applicationContext){
SpringUtil.context = applicationContext;
}
/**
* Spring在bean初始化后会判断是不是ApplicationContextAware的子类
* 如果该类是,setApplicationContext()方法,会将容器中ApplicationContext作为参数传入进去
*/
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
if (SpringUtil.context == null) {
SpringUtil.context = applicationContext;
}
}
public static void setContext(ApplicationContext applicationContext) {
if (SpringUtil.context == null) {
SpringUtil.context = applicationContext;
}
}
public static ApplicationContext getApplicationContext() {
return context;
}
/**
* 通过Name返回指定的Bean
*/
public static <T> T getBean(Class<T> beanClass) {
return context.getBean(beanClass);
}
public static <T>T getBean(String name,Class<T> beanClass) {
return context.getBean(name,beanClass);
}
/**
* 根据注解找到使用注解的类
* @param annotationType 注解class
* @return
*/
public static Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) {
return context.getBeansWithAnnotation(annotationType);
}
public static <T> Map<String, T> getBeansOfType(Class<T> type) {
return context.getBeansOfType(type);
}
}判空工具类
public class ValidateUtils {
private static final Pattern IS_NUMBER_PATTERN = Pattern.compile("-?[0-9]+(\\.[0-9]+)?");
private static Logger logger = LoggerUtils.logger(ValidateUtils.class);
/**
* 获取默认值
* @param obj 参数
* @param def 默认值
* @param <T>
* @return
*/
public static <T> T getOrDefault(T obj,T def){
return isEmpty(obj) ? def : obj;
}
public static boolean equals(String contrast, String var) {
return ObjectUtil.equals(contrast,var);
}
/**
* 判断值相等报错
*/
public static void equals(String contrast, String var, String errorCode) throws BaseException {
check(equals(contrast, var),new BaseException(errorCode));
}
/**
* 判断值相等报错
*/
public static void equals(String contrast, String var, String errorCode, Object... args) throws BaseException {
check(equals(contrast, var),new BaseException(errorCode, args));
}
/**
* 判断值不相等报错
*/
public static boolean notEquals(String contrast, String var) {
return !equals(contrast, var);
}
/**
* 判断值不相等报错
*/
public static void notEquals(String contrast, String var, String errorCode) throws BaseException {
check(notEquals(contrast, var),new BaseException(errorCode));
}
/**
* 判断值不相等报错
*/
public static void notEquals(String contrast, String var, String errorCode, Object... args) throws BaseException {
check(notEquals(contrast, var),new BaseException(errorCode, args));
}
public static boolean equalsIgnoreCase(String contrast, String var) {
boolean flag = false;
if(isEmpty(contrast) || isEmpty(var)){
return false;
}
if (contrast.equalsIgnoreCase(var)) {
flag = true;
}
return flag;
}
/**
* 判断值相等报错（忽略大小写）
*/
public static void equalsIgnoreCase(String contrast, String var, String errorCode) throws BaseException {
check(equalsIgnoreCase(contrast, var),new BaseException(errorCode));
}
/**
* 判断值相等报错（忽略大小写）
*/
public static void equalsIgnoreCase(String contrast, String var, String errorCode, Object... args)
throws BaseException {
check(equalsIgnoreCase(contrast, var),new BaseException(errorCode, args));
}
public static boolean notEqualsIgnoreCase(String contrast, String var) {
return !equalsIgnoreCase(contrast, var);
}
/**
* 判断值不相等报错（忽略大小写）
*/
public static void notEqualsIgnoreCase(String contrast, String var, String errorCode) throws BaseException {
check(notEqualsIgnoreCase(contrast, var),new BaseException(errorCode));
}
/**
* 判断值不相等报错（忽略大小写）
*/
public static void notEqualsIgnoreCase(String contrast, String var, String errorCode, Object... args) throws BaseException {
check(notEqualsIgnoreCase(contrast, var),new BaseException(errorCode, args));
}
public static boolean equals(Number contrast, Number var) {
return ObjectUtil.equals(contrast,var);
}
/**
* 判断值相等报错
*/
public static void equals(Number contrast, Number var, String errorCode) throws BaseException {
check(equals(contrast, var),new BaseException(errorCode));
}
/**
* 判断值相等报错
*/
public static void equals(Number contrast, Number var, String errorCode, Object... args) throws BaseException {
check(equals(contrast, var),new BaseException(errorCode, args));
}
public static boolean notEquals(Number contrast, Number var) {
return !equals(contrast, var);
}
/**
* 判断值不相等报错
*/
public static void notEquals(Number contrast, Number var, String errorCode) throws BaseException {
check(equals(contrast, var),new BaseException(errorCode));
}
/**
* 判断值不相等报错
*/
public static void notEquals(Number contrast, Number var, String errorCode, Object... args) throws BaseException {
if (notEquals(contrast, var)) {
throw new BaseException(errorCode, args);
}
}
public static boolean equals(Boolean contrast, Boolean var) {
return ObjectUtil.equals(contrast,var);
}
/**
* 判断值相等报错
*/
public static void equals(Boolean contrast, Boolean var, String errorCode) throws BaseException {
check(equals(contrast, var),new BaseException(errorCode));
}
/**
* 判断值相等报错
*/
public static void equals(Boolean contrast, Boolean var, String errorCode, Object... args) throws BaseException {
check(equals(contrast, var),new BaseException(errorCode, args));
}
public static boolean notEquals(Boolean contrast, Boolean var) {
return !equals(contrast, var);
}
/**
* 判断值不相等报错
*/
public static void notEquals(Boolean contrast, Boolean var, String errorCode) throws BaseException {
check(notEquals(contrast, var),new BaseException(errorCode));
}
/**
* 判断值不相等报错
*/
public static void notEquals(Boolean contrast, Boolean var, String errorCode, Object... args) throws BaseException {
check(notEquals(contrast, var),new BaseException(errorCode, args));
}
/**
* 判断传入的数字类型的值是否等于0或者是否为空，如果等于0或者等于空都会返回一个true
* @param number
* @return
*/
public static boolean isZero(Object number){
boolean flag = false;
if(isEmpty(number) || equals(String.valueOf(number),"0") || equals(String.valueOf(number),"0.0")){
flag = true;
}
return flag;
}
/**
* 判断是否为数字
*
* @param str
* @return
*/
public static boolean isNumber(String str) {
return regular(IS_NUMBER_PATTERN,str);
}
private static void check(boolean flag,BaseException e) throws BaseException {
if(flag){
throw e;
}
}
public static boolean regular(Pattern pattern,Object object){
if (ValidateUtils.isEmpty(object)) {
return false;
}
String bigStr;
try {
bigStr = object.toString();
} catch (Throwable e) {
logger.info("正则校验报错异常,传入的值为:{},异常为:{}",object,e);
return false;
}
Matcher matcher = pattern.matcher(bigStr);
return matcher.matches();
}
public static String camelName(String name) {
StringBuilder result = new StringBuilder();
// 快速检查
if (name == null || name.isEmpty()) {
// 没必要转换
return "";
} else if (!name.contains("_")) {
// 不含下划线，仅将首字母小写
return name.substring(0, 1).toLowerCase() + name.substring(1).toLowerCase();
}
// 用下划线将原始字符串分割
String camels[] = name.split("_");
for (String camel : camels) {
// 跳过原始字符串中开头、结尾的下换线或双重下划线
if (camel.isEmpty()) {
continue;
}
// 处理真正的驼峰片段
if (result.length() == 0) {
// 第一个驼峰片段，全部字母都小写
result.append(camel.toLowerCase());
} else {
// 其他的驼峰片段，首字母大写
result.append(camel.substring(0, 1).toUpperCase());
result.append(camel.substring(1).toLowerCase());
}
}
return result.toString();
}
/**
* 判断是否为空
*
* @param obj
* @return
*/
public static final Boolean isEmpty(Object obj) {
if(ObjectUtil.isEmpty(obj)){
return true;
}
return false;
}
/**
* 判断是否为空
*
* @param obj 对象
* @param errorCode 报错异常
*/
public static <T> T isEmpty(T obj, String errorCode) throws BaseException {
return isEmpty(obj, errorCode, (String[]) null);
}
/**
* 判断是否为空
*
* @param obj 对象
* @param errorCode 报错异常
* @param args 可替换的信息
*/
public static <T> T isEmpty(T obj, String errorCode, Object... args) throws BaseException {
if (isEmpty(obj)) {
throw new BaseException(errorCode, args);
}
return obj;
}
/**
* 判断对象是否非空
*
* @param obj 对象
* @return {@code true}: 非空<br>
* {@code false}: 空
*/
public static boolean isNotEmpty(Object obj) {
return !isEmpty(obj);
}
/**
* 判断对象是否非空
*
* @param obj 对象
* @param errorCode 报错异常
*/
public static <T> T isNotEmpty(T obj, String errorCode) throws BaseException {
return isNotEmpty(obj, errorCode, (String[]) null);
}
/**
* 判断对象是否非空
*
* @param obj 对象
* @param code 报错异常
* @param args 可替换的信息
*/
public static <T> T isNotEmpty(T obj, String code, Object... args) throws BaseException {
if (!isEmpty(obj)) {
throw new BaseException(code, args);
}
return obj;
}
/**
* 检查枚举是否不符合
* @param value 枚举名称
* @param clazz 枚举class
* @return
*/
public static boolean checkEnumValueIsEmpty(String value,Class clazz){
Enum enums = Enum.valueOf(clazz,value);
return isEmpty(enums) ? true : false;
}
/**
* 检查枚举是否不符合
* @param value 枚举名称
* @param clazz 枚举class
* @return
*/
public static void checkEnumValueIsEmpty(String value,Class clazz,String errorCode,String[] args) throws BaseException {
if(checkEnumValueIsEmpty(value,clazz)){
throw new BaseException(errorCode, args);
}
}
public static void checkEnumValueIsEmpty(String value,Class clazz,String errorCode) throws BaseException {
if(checkEnumValueIsEmpty(value,clazz)){
throw new BaseException(errorCode, (String) null);
}
}
/**
* 检查枚举是否符合
* @param value 枚举名称
* @param clazz 枚举class
* @return
*/
public static boolean checkEnumValueIsNotEmpty(String value,Class clazz){
return !checkEnumValueIsEmpty(value,clazz);
}
public static void checkEnumValueIsNotEmpty(String value,Class clazz,String errorCode,String[] args) throws BaseException {
if(checkEnumValueIsNotEmpty(value,clazz)){
throw new BaseException(errorCode, args);
}
}
public static void checkEnumValueIsNotEmpty(String value,Class clazz,String errorCode) throws BaseException {
if(checkEnumValueIsNotEmpty(value,clazz)){
throw new BaseException(errorCode, (String) null);
}
}
}
拦截器处理时区，从请求头获取Timezone获取时区
@Configuration()
public class RequestFilter extends OncePerRequestFilter {
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws ServletException, IOException {
//设置时区值
ExceptionUtil.requestId.set(UUID.randomUUID().toString());
RequestHeaderHolder.setTimeZone(request.getHeader(BaseCode.TIMEZONE));
//往下执行
chain.doFilter(new ContentCachingRequestWrapper(request), response);
}
}public class RequestHeaderHolder {
protected static final ThreadLocal<RequestHeader> threadLocal = ThreadLocal.withInitial(() -> {
RequestHeader header = new RequestHeader();
return header;
});
public static String getTimeZone(){
String serverTimeZone = threadLocal.get().getTimezone();
serverTimeZone = ValidateUtils.getOrDefault(serverTimeZone,ZoneId.systemDefault().getId());
try {
ZoneId.of(serverTimeZone);
} catch (Throwable e){
serverTimeZone = ZoneId.systemDefault().getId();
}
return serverTimeZone;
}
public static void setTimeZone(String serverTimeZone) {
threadLocal.get().setTimezone(serverTimeZone);
}
}
187
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
