Java文件上传方法

/**
 * 文件上传
 */
@RequestMapping("/upload")
@RestController
@IgnoreToken
@SuppressWarnings("all")
public class FilesController extends BaseController {


    @Value("${upload.filePath}")
    private String filePath;//文件上传路径
    @Value("${upload.requestPath}")
    private String requestPath;//文件请求路径

    public String getRequestPath() {
        return requestPath;
    }

    public String getFilePath() {
        return filePath;
    }

    //允许的上传文件后缀类型
    @Value("${upload.allowExt}")
    private String allowExt;

    public String getAllowExt() {
        return allowExt;
    }

    //允许文件上传最大限制
    @Value("${upload.fileSize}")
    private String fileSize;

    public String getFileSize() {
        return fileSize;
    }

    @Value("${spring.application.name}")
    private String serviceName;

    public String getServiceName() {
        return serviceName;
    }

    //系统地址
    @Value("${upload.domain}")
    private String hostname;

    public String getHostname() {
        return hostname;
    }


    /**
     * 重命名文件
     * @param fileName
     * @return
     */
    public String getFileName(String fileName) {
        if (fileName.length() > 0 && fileName.indexOf(".") > -1) {
            String ext;
            if (fileName.indexOf("?") > -1 && fileName.lastIndexOf("?") > fileName.lastIndexOf(".")) {
                ext = fileName.substring(fileName.lastIndexOf("."), fileName.lastIndexOf("?"));
            } else {
                ext = fileName.substring(fileName.lastIndexOf("."), fileName.length());
            }
            //限定支持
            if (!checkExt(ext)) {
                return "-1";//格式错误
            }
            return DateUtil.getCurrentDateStr() + "_" + UtilTools.getUUID() + ext;
        }
        return "";
    }

    /**
     * 判断是否在允许范围内的后缀
     * @param ext
     * @return
     */
    public boolean checkExt(String ext) {
        if (ext.length() == 0) {
            return false;
        }
        String[] params = getAllowExt().split("\\|");
        for (int i = 0; i < params.length; i++) {
            if (params[i].equals(ext)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 导入多个文件上传
     */
    @RequestMapping(value = "/uploadfiles", method = RequestMethod.POST)
    public Result loadingIn(MultipartHttpServletRequest mulRequest) throws Exception {

        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        request.getSession().setAttribute("language", "CN");
        /*if("CN".equals(content.getLanguage())){
            request.getSession().setAttribute("language","CN");
        }else {
            request.getSession().setAttribute("language","EN");
        }*/
        Set<Map.Entry<String, MultipartFile>> set = mulRequest.getFileMap().entrySet();
        Map<String, String> listFile = new LinkedHashMap<>();
        //System.out.println("上传个数" + set.size());
        int i = 0;
        for (Map.Entry<String, MultipartFile> each : set) {
            MultipartFile file = each.getValue();


            //如果上传文件为空
            if (UtilTools.isEmpty(file.getOriginalFilename())) {
                continue;
            }
            //System.out.println("上传文件名:"+file.getOriginalFilename());
            String newName = getFileName(file.getOriginalFilename());
            //如果上传文件类型不允许
            if ("-1".equals(newName)) {
                return setResult("controller1007");
            }
            //System.out.println("fileSize:"+file.getSize());
            int filesize = Integer.parseInt(getFileSize());
            if (file.getSize() > filesize) {
                return setResult("controller1008" + UtilTools.fileSizeConver(filesize) + "");
            }

            i++;
        }
        //是否存在上传文件
        if (i == 0) {
            return setResult("controller1009");
        }


        //进行文件上传
        String uploadPath = mulRequest.getParameter("uploadPath");//获取其它元素值
        String filesPath = UtilTools.isEmpty(uploadPath) ? "/" + this.getRequestPath() : "/" + this.getRequestPath() + uploadPath;
        uploadfile(filesPath, listFile, set);
        return setResult(listFile, "controller1010");
    }


    /**
     * 进行文件上传
     * @param filePath
     * @param listFile
     * @param set
     * @throws Exception
     */
    public void uploadfile(String filePath, Map<String, String> listFile, Set<Map.Entry<String, MultipartFile>> set) throws Exception {
        for (Map.Entry<String, MultipartFile> each : set) {
            String fileName = each.getKey();
            MultipartFile file = each.getValue();
            //如果上传文件为空
            String uploadFile = file.getOriginalFilename();
            if (UtilTools.isEmpty(uploadFile)) {
                continue;
            }
            String newName = getFileName(uploadFile);
            if (UtilTools.isEmpty(newName)) {
                String originalFilename = file.getOriginalFilename();
                if ("file".equals(originalFilename)) {
                    originalFilename = ".png";
                }
                newName = DateUtil.getCurrentDateStr() + "_" + UtilTools.getUUID() + originalFilename;
            }

            listFile.put(fileName, getHostname() + getServiceName() + filePath + newName);
            //重命名上传文件
            IoUtil.uploadFile(file.getBytes(), filePath, newName);
        }
    }

    /**
     * 上传Base64图片
     * @param file
     * @return
     * @throws Exception
     */
    @RequestMapping(value = "/uploadBase64File", method = RequestMethod.POST)
    @IgnoreSpecialChar
    public Result uploadBase64File(String file) throws Exception {

        if (UtilTools.isEmpty(file)) {
            Map<String, String> paramMap = getParamsMap();
            file = paramMap.get("file");
        }
        Map<String, String> listFile = new LinkedHashMap<>();
        String strFilePath = "/" + this.getRequestPath() + "base64File/";
        Map<String, MultipartFile> map = new HashMap();
        if(file.indexOf(",")==-1){
            return setResult("请添加Base64前缀 data:image/png;base64,");
        }
        map.put("file", base64toMultipart(file));
        Set<Map.Entry<String, MultipartFile>> set = map.entrySet();
        uploadfile(strFilePath, listFile, set);
        return setResult(listFile, "controller1010");
    }


    /**
     * Base64转化为MultipartFile
     * @param data 前台传过来base64的编码
     * @return
     */

    public MultipartFile base64toMultipart(String data) {
        try {
            data = data.replaceAll(" ", "+");
            String[] baseStrs = data.split(",");
            BASE64Decoder decoder = new BASE64Decoder();
            byte[] b = decoder.decodeBuffer(baseStrs[1]);
            for (int i = 0; i < b.length; ++i) {
                if (b[i] < 0) {
                    b[i] += 256;
                }
            }
            return new Base64MultipartFile(b, baseStrs[0], "file");
        } catch (IOException e) {
            throw new ResultException("controller1008");
        }
    }


}

/**
 * 父类接收参数、处理参数、返回实体等
 */
public class BaseController extends BaseResult {

    private static final Logger log = LoggerFactory.getLogger(BaseController.class);

    /**
     * 获取token参数
     * @param token
     * @return
     */
    public String getToken(String token){
        Map<String, String> params = new HashMap<>();
        if (StringUtils.isBlank(token) ) {
            params = getParamsMap();
        }else{
            params.put("token",token);
        }
       return params.get("token");
    }


    /**
     * 自动获取所有参数
     * @return
     */
    public static Map<String, String> getParamsMap() {
        Map<String, String> paramsMap = new HashMap<>();
        try {
            ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
            HttpServletRequest request = servletRequestAttributes.getRequest();
            String json = jsonRequest(request);
            if (StringUtils.isNotBlank(json)) {
                return JSONObject.parseObject(json, Map.class);
            }
        } catch (Exception e) {
            log.error("base1001", e.getMessage());
        }
        return paramsMap;
    }



    //自定义返回信息描述
    @Override
    public Result setResult(Object obj,String msg) {
        return setResult(obj==null?-1:1, msg,obj==null?new JSONObject():obj);
    }
    //验证失败，返回错误提示
    @Override
    public Result setResult(String msg) {
        return setResult(null,msg);
    }

    @Override
    public Result setResult(int code, String msg, Object obj) {
        return new Result(code,msg,obj);
    }

    @Override
    public Result setResult(Object obj){
        return setResult(obj,"base1002");
    }

}

/**
 * 抽象返回方法
 */
public abstract class BaseResult {


    abstract Result setResult(Object obj);

    abstract Result setResult(Object obj,String msg);

    abstract Result setResult(String msg);

    abstract Result setResult(int code,String msg,Object obj);
}

/**
 * 自定义返回实体及抽象校验方法
 */
public abstract class BaseService extends BaseResult {

       //请求成功，正常返回数据
       @Override
       public Result setResult(Object obj) {
              return setResult(obj,"base1002");
       }
       //自定义返回信息描述
       @Override
       public Result setResult(Object obj,String msg) {
              return setResult(obj==null?-1:1, msg, obj==null?new JSONObject():obj);
       }
       //验证失败，返回错误提示
       @Override
       public Result setResult(String msg) {
              return setResult(null,msg);
       }
       //实例化一个返回对象
       @Override
       public Result setResult(int code,String msg,Object obj) {
              return new Result(code,msg,obj);
       }

       public abstract Result checkVaild(Object obj);

       public Stream setResultMap(String key,Object value){
              return new Stream(new ConcurrentHashMap<>()).add(key,value);
       }

       public  Map<String,Object> setResultMap(){
              return setResultMap("result");
       }

       public  Map<String,Object> setResultMap(String key){
              return setMap(key,true);
       }

       public Map<String,Object> setMap(String key,Object value){
              Map<String,Object> resultMap = new ConcurrentHashMap<>();
              resultMap.put(key,value);
              return resultMap;
       }
       /**
        * 去重数据
        * @param keyExtractor
        * @param <T>
        * @return
        */
       public static <T> Predicate<T> distinctByKey(Function<? super T, Object> keyExtractor) {
              Map<Object, Boolean> map = new ConcurrentHashMap<>();
              return t -> map.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
       }

}

/**
 * 自定义工具类
 */
public class UtilTools {

	public static final String ALL_CHAR = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
	/**
	 * 获取UUID
	 * 格式化UUID
	 * @return
     */
	public static String getUUID(){
		return UUID.randomUUID().toString().replaceAll("-","");
	}


	/**
	 * 获取随机数
	 * @param length
	 * @return
     */
	public static String getRandom(int length,String strChar){
		if(strChar.length()==0){return "";}
		StringBuffer sb = new StringBuffer();
		Random random = new Random();
		for (int i = 0; i < length; i++) {
			sb.append(strChar.charAt(random.nextInt(strChar.length())));
		}
		return sb.toString();
	}
	public static String getRandomNumber(int length){
		return getRandom(length,ALL_CHAR.substring(0,10));
	}

	public static String getRandomChar(int length){
		return getRandom(length,ALL_CHAR);
	}


	/**
	 * 默认获取8位随机数
	 * @return
     */
	public static String getRandom(){return getRandomNumber(6);}

	/**
	 * 文件大小转化名称显示
	 * @param fileSize
	 * @return
     */
	public static String fileSizeConver(int fileSize)
	{
		DecimalFormat df = new DecimalFormat("#");
		String fileSizeString = "";
		String wrongSize="0B";
		if(fileSize==0){
			return wrongSize;
		}
		if (fileSize < 1024){
			fileSizeString = df.format(fileSize) + "B";
		}
		else if (fileSize < 1048576){
			fileSizeString = df.format(fileSize / 1024) + "KB";
		}
		else if (fileSize < 1073741824){
			fileSizeString = df.format(fileSize / 1048576) + "MB";
		}
		else{
			fileSizeString = df.format(fileSize / 1073741824) + "GB";
		}
		return fileSizeString;
	}


    /**
     * 正则表达式数字验证
     * @param str
     * @return
     */
    public static boolean isNumber(String str) {
        if (str != null && !"".equals(str)) {
            java.util.regex.Pattern pattern = java.util.regex.Pattern.compile("[0-9]*");
            java.util.regex.Matcher match = pattern.matcher(str);
            return match.matches();
        } else {
            return false;
        }
    }

    /**
     * 字符串非空非null判断
     */
    public static boolean isEmpty(String val) {
        if (val == null || val.length() == 0 || "null".equalsIgnoreCase(val)) {
            return true;
        } else {
            return false;
        }
    }
   
	 /**
     * 解码数据
     * @param text
     * @return
     * @throws UnsupportedEncodingException
     */
    public static String deCodeStr(String text) throws UnsupportedEncodingException{
		String str="";
		if(!isEmpty(text)){
			str= URLDecoder.decode(text,"UTF-8");
		}
		return str;
	}

	/**
	 * 获取JSON数据
	 * @param object
	 * @return
     */
	public static JSONObject getJsonObject(Object object){
		return JSON.parseObject(object.toString());
	}


	/**
	 * 实体对象转成Map
	 * @param obj 实体对象
	 * @return
	 */
	public static Map<String, Object> object2Map(Object obj) {
		Map<String, Object> map = new HashMap<>();
		if (obj == null) {
			return map;
		}
		Class clazz = obj.getClass();
		Field[] fields = clazz.getDeclaredFields();
		try {
			for (Field field : fields) {
				field.setAccessible(true);
				map.put(field.getName(), field.get(obj));
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return map;
	}

    
    /**
     * 补0
     * @package com.util.tools
     * @date 2016-12-23
     * @method UtilTools.supplementNum()
     * @return
     */
    public static String supplementNum(String str,int num){
    	if(str.length()<num){
    		str="0"+str;
    	}else{
    		return str;
    	}
    	return supplementNum(str,num);
    }
   
    
    
    /**
     * 使用java连接AD域
     * @param host 连接AD域服务器的IP
     * @param post AD域服务器的端口
     * @param username 用户名
     * @param password 密码
     * @return Integer 1 success 、0  false 、 -1 exception  
     */
    public static Integer connectAD(String host,String post,String username,String password) {
        DirContext ctx=null;
        int isLogin = 0;
        Hashtable<String,String> hashEnv = new Hashtable<String,String>();
		hashEnv.put(Context.SECURITY_AUTHENTICATION, "simple"); // LDAP访问安全级别(none,simple,strong)
		hashEnv.put(Context.SECURITY_PRINCIPAL, username!=null?username:""); //AD的用户名
		hashEnv.put(Context.SECURITY_CREDENTIALS, password!=null?password:""); //AD的密码
		hashEnv.put(Context.INITIAL_CONTEXT_FACTORY,"com.sun.jndi.ldap.LdapCtxFactory"); // LDAP工厂类
		hashEnv.put("com.sun.jndi.ldap.connect.timeout","3000");//连接超时设置为3秒
		hashEnv.put(Context.PROVIDER_URL," ldap://" + host + ":" + post);//默认端口389
        try {
        	if(password!=null&&!"".equals(password)){
	            ctx = new InitialDirContext(hashEnv);//初始化上下文
	            //System.out.println("身份验证成功!");
	            isLogin = 1;
        	}else{
        		//System.out.println("身份验证失败!");
        		isLogin = 0;//没有输入密码属于身份失败
        	}
            
        } catch (AuthenticationException e) {
            //System.out.println("身份验证失败!");
            e.printStackTrace();
            isLogin = 0;
        } catch (javax.naming.CommunicationException e) {
            //System.out.println("AD域连接失败!");
            e.printStackTrace();
            isLogin = -1;
        } catch (Exception e) {
            //System.out.println("身份验证未知异常!");
            e.printStackTrace();
            isLogin = -1;
        } finally{
            if(null!=ctx){
                try {
                    ctx.close();
                    ctx=null;
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        return isLogin;
    }




	/**
	 * 获取请求IP地址
	 * @return
	 */
	public static String getIpAddr() {
		ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
		HttpServletRequest request = requestAttributes.getRequest();
		String ipAddress = null;
		//ipAddress = this.getRequest().getRemoteAddr();
		ipAddress = request.getHeader("x-forwarded-for");
		if(ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
			ipAddress = request.getHeader("Proxy-Client-IP");
		}
		if(ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
			ipAddress = request.getHeader("WL-Proxy-Client-IP");
		}
		if(ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
			ipAddress = request.getRemoteAddr();
			if("127.0.0.1".equals(ipAddress) || "0:0:0:0:0:0:0:1".equals(ipAddress)){
				//根据网卡取本机配置的IP
				InetAddress inet=null;
				try {
					inet = InetAddress.getLocalHost();
				} catch (UnknownHostException e) {
					e.printStackTrace();
				}
				ipAddress= inet.getHostAddress();
			}

		}

		//对于通过多个代理的情况，第一个IP为客户端真实IP,多个IP按照','分割
		if(ipAddress!=null && ipAddress.length()>15){ //"***.***.***.***".length() = 15
			if(ipAddress.indexOf(",")>0){
				ipAddress = ipAddress.substring(0,ipAddress.indexOf(","));
			}
		}
		return ipAddress;
	}



	/**
	 * 半角转全角
	 * 
	 * @param input
	 *            String.
	 * @return 全角字符串.
	 */
	public static String toSBC(String input) {
		char [] c = input.toCharArray();
		for (int i = 0; i < c.length; i++) {
			if (c[i] == ' ') {
				c[i] = '\u3000';
			} else if (c[i] < '\177') {
				c[i] = (char) (c[i] + 65248);
			}
		}
		return new String(c);
	}

	/**
	 * 全角转半角
	 * 
	 * @param input
	 *            String.
	 * @return 半角字符串
	 */
	public static String toDBC(String input) {

		char [] c = input.toCharArray();
		for (int i = 0; i < c.length; i++) {
			if (c[i] == '\u3000') {
				c[i] = ' ';
			} else if (c[i] > '\uFF00' && c[i] < '\uFF5F') {
				c[i] = (char) (c[i] - 65248);
			}
		}
		return new String(c);
	}
}

import java.io.*;

/**
 * 文件操作工具类
 */
public class IoUtil {


	/**
	 * 文件上传
	 * @param file
	 * @param filePath
	 * @param fileName
	 * @throws Exception
     */
	public static void uploadFile(byte[] file, String filePath, String fileName) throws Exception {
		File targetFile = new File(filePath);
		if(!targetFile.exists()){
			targetFile.mkdirs();
		}
		FileOutputStream out = new FileOutputStream(filePath+fileName);
		out.write(file);
		out.flush();
		out.close();
	}


	/**
	 * 查询数据文件是否正在被使用
	 * @param file
	 * @return
	 */
	public static boolean  isUsefile(File file){
		if(!file.renameTo(file)){
			System.out.println("文件正在被使用中...");
			return true;
		}else{
			//允许操作
			return  false;
		}
	}



	/**
	 * inputStream转outputStream
	 */
	public static ByteArrayOutputStream parseOut(InputStream in){
		ByteArrayOutputStream swapStream = new ByteArrayOutputStream();
		try {
			int ch;
			while ((ch = in.read()) != -1) {
                swapStream.write(ch);
            }
		} catch (IOException e) {

		}
		return swapStream;
	}

	/**
	 * byte to inputStream
	 * @param buffer
	 * @return
     */
	public static ByteArrayInputStream parseIn(byte[] buffer){
		return  new ByteArrayInputStream(buffer);
	}



	/**
	 * 读取文件内容
	 * @param path
	 * @return
	 */
	public static String getFileContent(String path) {
		String result="";
		try {
			FileReader fr = new FileReader(path);// 需要读取的文件路径
			BufferedReader br = new BufferedReader(fr);
			String str = br.readLine();
			result=str;
			while (str != null)// 如果当前行不为空
			{
				System.out.println(str);// 打印当前行
				str = br.readLine();// 读取下一行
				if(str!=null){
				  result+=str;
				}
			}
			br.close();// 关闭BufferReader流
			fr.close(); // 关闭文件流
		} catch (IOException e)// 捕捉异常
		{
			System.out.println("指定文件不存在");// 处理异常
		}
		return result;
	}
/**
	 * 读取文件路径
	 * @param path
	 * @return
	 */	
public static String getFileUrl(String path) {
		String result="";
		try {
			 String resource = Thread.currentThread().getContextClassLoader().getResource("").getPath();
//        E:/study/WorkerService/target/classes/
       		 String currentDirectory = System.getProperty("user.dir");
//       E:\study\WorkerService
		} catch (IOException e)// 捕捉异常
		{
			System.out.println("指定文件不存在");// 处理异常
		}
		return result;
	}

}