Java实现文件上传和url格式校验工具

package com.visy.enums;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.ReflectUtil;
import com.google.common.collect.Lists;
import com.visy.util.TsListUtil;
import lombok.AllArgsConstructor;
import lombok.Getter;
import org.apache.commons.lang3.ClassUtils;
import org.springframework.util.StringUtils;
import org.springframework.web.multipart.MultipartFile;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.util.*;
import java.util.stream.Collectors;

@Getter
@AllArgsConstructor
public enum FileNameSuffixEnum {
   FILE_TYPE_JPG("jpg", "JPG"),
   FILE_TYPE_JPEG("jpeg", "JPEG"),
   FILE_TYPE_PNG("png", "PNG"),

   FILE_TYPE_GIF("gif", "GIF"),
   FILE_TYPE_BMP("bmp", "BMP"),

   FILE_TYPE_APK("apk", "APK"),
   FILE_TYPE_PFX("pfx", "PFX"),
   FILE_TYPE_CRT("crt", "CRT"),
   FILE_TYPE_CER("cer", "CER"),
   FILE_TYPE_KEY("key", "KEY"),
   FILE_TYPE_P12("p12", "P12"),
   FILE_TYPE_TXT("txt", "TXT"),
   FILE_TYPE_ZIP("zip", "ZIP"),
   FILE_TYPE_ICO("ico", "ICO"),
   FILE_TYPE_WEBP("webp", "WEBP"),
   FILE_TYPE_PDF("pdf", "PDF"),

   FILE_TYPE_XLS("xls", "XLS"),
   FILE_TYPE_XLSX("xlsx", "XLSX");

   private final String key;
   private final String desc;

   public static final List<String> photoNameList = Lists.newArrayList(
      FILE_TYPE_JPG.getDesc(),
      FILE_TYPE_JPEG.getDesc(),
      FILE_TYPE_PNG.getDesc()
   );
   private static final List<String> imgNameList = TsListUtil.chain(photoNameList).addElements(
      FILE_TYPE_GIF.getDesc(),
      FILE_TYPE_BMP.getDesc()
   ).toList();
   private static final List<String> excelNameList = Lists.newArrayList(
      FILE_TYPE_XLS.getDesc(),
      FILE_TYPE_XLSX.getDesc()
   );
   private static final List<String> keyNameList = Lists.newArrayList(
      FILE_TYPE_PFX.getDesc(),
      FILE_TYPE_CRT.getDesc(),
      FILE_TYPE_CER.getDesc(),
      FILE_TYPE_KEY.getDesc(),
      FILE_TYPE_P12.getDesc()
   );
   private static final List<String> allFileNameList =
   TsListUtil.chain(imgNameList).addAll(excelNameList).addAll(keyNameList).addElements(
      FILE_TYPE_APK.getDesc(),
      FILE_TYPE_TXT.getDesc(),
      FILE_TYPE_ZIP.getDesc(),
      FILE_TYPE_ICO.getDesc(),
      FILE_TYPE_WEBP.getDesc(),
      FILE_TYPE_PDF.getDesc()
   ).toList();


   public static boolean isNotPhotoFile(MultipartFile file){
      return !isFileTypeOf(file, photoNameList);
   }
   public static boolean isNotImgFile(MultipartFile file){
      return !isFileTypeOf(file, imgNameList);
   }
   public static boolean isNotExcelFile(MultipartFile file){
      return !isFileTypeOf(file, excelNameList);
   }
   public static boolean isNotInstallFile(MultipartFile file){
      return !isFileTypeOf(file, Lists.newArrayList(FILE_TYPE_APK.getDesc()));
   }
   public static boolean isNotKeyFile(MultipartFile file){
      return !isFileTypeOf(file, keyNameList);
   }
   public static boolean isNotAllowFile(MultipartFile file){
      return !isFileTypeOf(file, allFileNameList);
   }

   public static boolean isNotPhotoUrl(Object obj, String ...fieldNames){
      return !isUrlTypeOf(photoNameList, obj, fieldNames);
   }
   public static boolean isNotImgUrl(Object obj, String ...fieldNames){
      return !isUrlTypeOf(imgNameList, obj, fieldNames);
   }
   public static boolean isNotKeyUrl(Object obj, String ...fieldNames){
      return !isUrlTypeOf(keyNameList, obj, fieldNames);
   }
   public static boolean isNotAllowUrl(Object obj, String ...fieldNames){
      return !isUrlTypeOf(allFileNameList, obj, fieldNames);
   }

   private static boolean isFileTypeOf(MultipartFile file, List<String> extensions){
      if (ObjectUtil.isNull(file)) {
         return true;
      }
      //获取文件扩展名
      String suffix = FileUtil.extName(file.getOriginalFilename());
      // 校验文件扩展名
      return StringUtils.hasText(suffix) && extensions.contains(suffix.toUpperCase());
   }

   private static boolean isUrlTypeOf(List<String> extensions, Object obj, String ...fieldNames){
      return isUrlTypeOf(extensions, obj, Arrays.stream(fieldNames).collect(Collectors.toSet()));
   }
   
   /**
    * 判断对象中指定的属性值是否是指定文件类型
    * @param extensions 允许的文件扩展名
    * @param obj 要检查的对象
    * @param fieldNames 要检查的属性名称列表
    * 对于集合、数组、Map、对象，会递归检查属性值
    * 要检查对象的非直接属性时，需要传递中间对象的名称，如： {"a": {"b": {"c": ["x.jpg"] }}}
    * 若要检查c列表中的url， fieldNames参数须为： "a", "b", "c"， 不能只传 "c"
    * @return 校验是否通过
    */
   private static boolean isUrlTypeOf(List<String> extensions, Object obj, Set<String> fieldNames){
      if(ObjectUtil.isNull(obj) || CollUtil.isEmpty(fieldNames)){
         return true;
      }
      if(ClassUtils.isPrimitiveOrWrapper(obj.getClass())){
         //排除基本类型及其包装类
         return true;
      }

      if(obj instanceof String){ //String
         return isUrlTypeOf(obj.toString(), extensions);
      }else if(obj instanceof Collection<?>){ //Collection
         for(Object item : (Collection<?>)obj){
            if(!isUrlTypeOf(extensions, item, fieldNames)){
               return false;
            }
         }
      }else if(clazz.isArray()){ //Array
         for (int i=0,l=Array.getLength(obj); i<l; i++) {
            if(!isUrlTypeOf(extensions, Array.get(obj, i), fieldNames)){
               return false;
            }
         }
      }else if(obj instanceof Map<?,?>){ //Map
         for(Map.Entry<?,?> entry : ((Map<?,?>)obj).entrySet()){
            if(
               fieldNames.contains(String.valueOf(entry.getKey()))
               && !isUrlTypeOf(extensions, entry.getValue(), fieldNames)
            ){
               return false;
            }
         }
      }else{ //Object
         for(Field field : ReflectUtil.getFields(obj.getClass())){
            if(
              fieldNames.contains(field.getName())
              && !isUrlTypeOf(extensions, ReflectUtil.getFieldValue(obj, field), fieldNames)
            ){
               return false;
            }
         }
      }

      return true;
   }
   private static boolean isUrlTypeOf(String url, List<String> extensions){
      if (!StringUtils.hasText(url)) {
         return true;
      }
      //获取文件扩展名
      String suffix = FileUtil.extName(url.trim());
      //校验文件扩展名
      return StringUtils.hasText(suffix) && extensions.contains(suffix.toUpperCase());
   }
}

package com.visy.util;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ReflectUtil;
import org.springframework.beans.BeanUtils;

import java.util.*;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class TsListUtil {

    public static <T,R> List<R> convert(List<T> list, Function<T,R> converter){
        return empty(list).stream().map(converter).collect(Collectors.toList());
    }

    public static <T,R> List<R> convert(List<T> list, Class<R> rClazz){
        return convert(list, item -> {
            R r = ReflectUtil.newInstance(rClazz);
            BeanUtils.copyProperties(item, r);
            return r;
        });
    }

    public static <T> List<T> empty(List<T> list){
        return Objects.isNull(list) ? new ArrayList<>() : list;
    }

    /**
     * 合并列表
     * @param list 列表
     * @param keyMapper 获取key的函数
     * @param merger 合并的函数
     * @return 合并后的列表
     * @param <K> key的类型
     * @param <V> 值类型
     */
    public static <K,V> List<V> mergeList(List<V> list, Function<V,K> keyMapper, BiFunction<? super V, ? super V, ? extends V> merger) {
        if (CollUtil.isEmpty(list)) {
            return Collections.emptyList();
        }

        Map<K, V> mergedMap = new LinkedHashMap<>(); //保持顺序
        for (V item : list) {
            mergedMap.merge(keyMapper.apply(item), item, merger);
        }

        return new ArrayList<>(mergedMap.values());
    }

    public static <T> ListChain<T> chain(List<T> list) {
        return new ListChain<>(list);
    }

    public static class ListChain<T> {
        private final List<T> list;

        private ListChain(List<T> list) {
            //注意这里是拷贝一份，但也不是深度拷贝，修改内部的对象仍需谨慎
            this.list = list==null ? new ArrayList<>() : new ArrayList<>(list);
        }

        public ListChain<T> removeIf(Predicate<? super T> filter) {
            this.list.removeIf(filter);
            return this;
        }

        public ListChain<T> forEach(Consumer<? super T> action){
            this.list.forEach(action);
            return this;
        }

        public ListChain<T> addAll(List<T> otherList){
            this.list.addAll(otherList);
            return this;
        }

        @SafeVarargs
        public final ListChain<T> addElements(T... elements){
            if(elements!=null && elements.length>0){
                this.list.addAll(Arrays.asList(elements));
            }
            return this;
        }

        public <K> ListChain<T> merge(Function<T,K> keyMapper, BiFunction<? super T, ? super T, ? extends T> merger){
            return new ListChain<>(mergeList(this.list, keyMapper, merger));
        }

        public List<T> toList(){
            return this.list;
        }

        public Stream<T> stream(){
            return toList().stream();
        }
    }
}