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