图片上传下载工具类

public class UploadUtil {

    private static UploadUtil uploadUtil;
    private static final String BOUNDARY = UUID.randomUUID().toString(); // 边界标识
                                                                            // 随机生成
    private static final String PREFIX = "--";
    private static final String LINE_END = "\r\n";
    private static final String CONTENT_TYPE = "multipart/form-data"; // 内容类型

    /**
     * 获得上传成功后的路径
     */
    private static String result = null;

    private UploadUtil() {
    }

    /**
     * 单例模式获取上传工具类
     * 
     * @return
     */
    public static UploadUtil getInstance() {
        result = null;
        if (null == uploadUtil) {
            uploadUtil = new UploadUtil();
        }
        return uploadUtil;
    }

    private int readTimeOut = 30 * 1000; // 读取超时 30s
    private int connectTimeout = 60 * 1000; // 超时时间 1分钟

    /***
     * 请求使用多长时间
     */
    private static int requestTime = 0;

    private static final String CHARSET = "utf-8"; // 设置编码

    /**
     * 图片上传URL
     */
    public static final String IMAGE_UPLOAD_PATH = DomainUrlUtil.IMAGE_SERVER_ADDR + "/imageUploadServlet";

    /**
     * 上传到ftp服务器
     * 
     * @param file
     * @param request
     * @param param
     * @return
     */
    public String upload2FTP(String file, HttpServletRequest request, Map<String, String> param) {
        File tempfile = null;
        try {
            tempfile = getTempFile(request, file);

            if (ComonUtils.isNUll(tempfile)) {
                return null;
            }
            String path = buildPath(param);

            // 文件名：UUID+扩展名
            String filename = UUID.randomUUID().toString()
                    + tempfile.getName().substring(tempfile.getName().lastIndexOf("."));

            boolean success = FtpUtil.uploadFile(path, filename, new FileInputStream(tempfile));
            if (success) {
                // 上传成功，返回路径
                String returnpath = "/" + path + "/" + filename;
                return returnpath;
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 上传完毕后，将临时文件删除
            if (tempfile != null)
                tempfile.delete();
        }
        return null;
    }

    /**
     * 根据是否使用FTP上传自动选择上传方式
     * 
     * @param file
     * @param request
     * @param param
     * @return
     */
    public String uploadFile(String file, HttpServletRequest request, Map<String, String> param) {
        if (DomainUrlUtil.USE_FTP_MODEL) {
            return upload2FTP(file, request, param);
        } else {
            return uploadFile2ImageServer(file, request, param);
        }
    }

    /**
     * 以map的key－value构建虚拟路径
     * 
     * @param param
     * @return
     */
    private String buildPath(Map<String, String> param) {
        StringBuffer path = new StringBuffer();
        param.forEach((k, v) -> {
            path.append(k).append("/").append(v);
        });
        return path.toString();
    }

    /**
     * 上传至图片服务器，不指定图片宽高，不剪裁图片
     * 
     * @param file
     * @param request
     * @param param
     * @return
     */
    public String uploadFile2ImageServer(String file, HttpServletRequest request, Map<String, String> param) {
        return uploadFile2ImageServer(file, request, null, null, param);
    }

    /**
     * 上传图片到图片服务器，根据指定宽高剪裁图片
     * 
     * @param file
     * @param request
     * @param width
     * @param height
     * @param params
     * @return
     */
    public String uploadFile2ImageServer(String file, HttpServletRequest request, String width, String height,
            Map<String, String> params) {
        if (width != null && height != null) {
            params.put("pic_width", width);
            params.put("pic_height", height);
        }
        uploadFile(getTempFile(request, file), "pic", IMAGE_UPLOAD_PATH, params);
        if (result != null && !"".equals(result)) {
            // 规范路径
            return result.replaceAll("\\\\", "/");
        }
        return null;

    }

    /**
     * 从表单文件流中读出文件
     * 
     * @param request
     * @param file
     * @return
     */
    private File getTempFile(HttpServletRequest request, String file) {
        MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
        // 表单文件流
        CommonsMultipartFile multipartFile = (CommonsMultipartFile) multipartRequest.getFile(file);
        File tmpFile = null;
        try {
            if (null != multipartFile && multipartFile.getSize() > 0) {

                tmpFile = new File(buildImgPath(request) + "/" + multipartFile.getOriginalFilename());
                if (!multipartFile.isEmpty()) {
                    byte[] bytes = multipartFile.getBytes();
                    BufferedOutputStream stream = new BufferedOutputStream(new FileOutputStream(tmpFile));
                    stream.write(bytes);
                    stream.close();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return tmpFile;
    }

    /**
     * 构建图片上传路径
     * 
     * @param request
     * @return
     */
    private String buildImgPath(HttpServletRequest request) {
        String path = "upload";
        SimpleDateFormat formater = new SimpleDateFormat("yyyyMMdd");
        path += "/" + formater.format(new Date());
        path = request.getServletContext().getRealPath(path);
        File dir = new File(path);
        if (!dir.exists()) {
            try {
                dir.mkdirs();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return path;
    }

    /**
     * 上传文件
     * 
     * @param file
     *            需要上传的文件
     * @param fileKey
     *            在网页上<input type=file name=xxx/> xxx就是这里的fileKey
     * @param RequestURL
     *            请求的URL
     * @param param
     *            传递参数
     */
    public void uploadFile(File file, String fileKey, String RequestURL, Map<String, String> param) {
        if (file == null || (!file.exists())) {
            return;
        }

        requestTime = 0;

        long requestTime = System.currentTimeMillis();
        long responseTime = 0;

        try {
            URL url = new URL(RequestURL);
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setReadTimeout(readTimeOut);
            conn.setConnectTimeout(connectTimeout);
            conn.setDoInput(true); // 允许输入流
            conn.setDoOutput(true); // 允许输出流
            conn.setUseCaches(false); // 不允许使用缓存
            conn.setRequestMethod("POST"); // 请求方式
            conn.setRequestProperty("Charset", CHARSET); // 设置编码
            conn.setRequestProperty("connection", "keep-alive");
            conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)");
            conn.setRequestProperty("Content-Type", CONTENT_TYPE + ";boundary=" + BOUNDARY);
            // conn.setRequestProperty("Content-Type",
            // "application/x-www-form-urlencoded");

            /**
             * 当文件不为空，把文件包装并且上传
             */
            DataOutputStream dos = new DataOutputStream(conn.getOutputStream());
            StringBuffer sb = null;
            String params = "";

            /***
             * 以下是用于上传参数
             */
            if (param != null && param.size() > 0) {
                Iterator<String> it = param.keySet().iterator();
                while (it.hasNext()) {
                    sb = null;
                    sb = new StringBuffer();
                    String key = it.next();
                    String value = param.get(key);
                    sb.append(PREFIX).append(BOUNDARY).append(LINE_END);
                    sb.append("Content-Disposition: form-data; name=\"").append(key).append("\"").append(LINE_END)
                            .append(LINE_END);
                    sb.append(value).append(LINE_END);
                    params = sb.toString();
                    dos.write(params.getBytes());
                    // dos.flush();
                }
            }

            sb = null;
            params = null;
            sb = new StringBuffer();

            sb.append(PREFIX).append(BOUNDARY).append(LINE_END);
            sb.append("Content-Disposition:form-data; name=\"" + fileKey + "\"; filename=\"" + file.getName() + "\""
                    + LINE_END);
            sb.append("Content-Type:image/pjpeg" + LINE_END); // 这里配置的Content-type ，用于服务器端辨别文件的类型的
            sb.append(LINE_END);
            params = sb.toString();
            sb = null;

            dos.write(params.getBytes());
            /** 上传文件 */
            InputStream is = new FileInputStream(file);
            byte[] bytes = new byte[1024];
            int len = 0;
            while ((len = is.read(bytes)) != -1) {
                dos.write(bytes, 0, len);
            }
            is.close();

            dos.write(LINE_END.getBytes());
            byte[] end_data = (PREFIX + BOUNDARY + PREFIX + LINE_END).getBytes();
            dos.write(end_data);
            dos.flush();

            /**
             * 获取响应码 200=成功 当响应成功，获取响应的流
             */
            int res = conn.getResponseCode();
            responseTime = System.currentTimeMillis();
            requestTime = (int) ((responseTime - requestTime) / 1000);

            // 删除临时文件
            delete(file);

            if (res == 200) {
                InputStream input = conn.getInputStream();
                StringBuffer sb1 = new StringBuffer();
                int ss;
                while ((ss = input.read()) != -1) {
                    sb1.append((char) ss);
                }
                result = sb1.toString();
            }
            return;
        } catch (MalformedURLException e) {
            e.printStackTrace();
            return;
        } catch (IOException e) {
            e.printStackTrace();
            return;
        }
    }

    private static void delete(File file) {
        File parentFile = file.getParentFile();
        String name = parentFile.getName();
        if(name == "upload" || name.equals("upload")) {
            del(parentFile);
        } else {
            delete(parentFile);
        }
    }
    private static void del(File file) {
        File[] listFiles = file.listFiles();
        if(listFiles != null) {
            for (File file2 : listFiles) {
                if(file2.isFile()) {
                    file2.delete();
                } else if(file2.isDirectory()) {
                    del(file2);
                    file2.delete();
                }
            }
            file.delete();
        }
    }

    public int getReadTimeOut() {
        return readTimeOut;
    }

    public void setReadTimeOut(int readTimeOut) {
        this.readTimeOut = readTimeOut;
    }

    public int getConnectTimeout() {
        return connectTimeout;
    }

    public void setConnectTimeout(int connectTimeout) {
        this.connectTimeout = connectTimeout;
    }

    /**
     * 获取上传使用的时间
     * 
     * @return
     */
    public static int getRequestTime() {
        return requestTime;
    }

    public String getResult() {
        return result;
    }

}

public class FtpUtil {
    // ftp默认端口
    private static final int port = 21;
    private static String username;
    private static String pwd;
    // 文件路径
    public static String UPLOAD_PATH;

    /**
     * 默认的端口和用户上传
     * 
     * @param host
     * @param basePath
     * @param filePath
     * @param filename
     * @param input
     * @return
     */
    public static boolean uploadFile(String filePath, String filename, InputStream input) {
        return uploadFile(port, username, pwd, filePath, filename, input);
    }

    /**
     * @param port
     *            FTP服务器端口
     * @param username
     *            FTP登录账号
     * @param password
     *            FTP登录密码
     * @param basePath
     *            FTP服务器基础目录
     * @param filePath
     *            FTP服务器文件存放路径。文件的路径为basePath+filePath
     * @param filename
     *            上传到FTP服务器上的文件名
     * @param input
     *            输入流
     * @return 成功返回true，否则返回false
     */
    public static boolean uploadFile(int port, String username, String password, String filePath, String filename,
            InputStream input) {
        boolean result = false;
        FTPClient ftp = new FTPClient();
        try {
            int reply;
            ftp.connect(DomainUrlUtil.FTP_SERVER_ADDR, port);// 连接FTP服务器
            // 如果采用默认端口，可以使用ftp.connect(host)的方式直接连接FTP服务器
            ftp.login(username, password);// 登录
            reply = ftp.getReplyCode();
            if (!FTPReply.isPositiveCompletion(reply)) {
                ftp.disconnect();
                return result;
            }
            // 切换到上传目录
            if (!ftp.changeWorkingDirectory(UPLOAD_PATH + filePath)) {
                // 如果目录不存在创建目录
                String[] dirs = filePath.split("/");
                String tempPath = UPLOAD_PATH;
                for (String dir : dirs) {
                    if (null == dir || "".equals(dir))
                        continue;
                    tempPath += "/" + dir;
                    if (!ftp.changeWorkingDirectory(tempPath)) {
                        if (!ftp.makeDirectory(tempPath)) {
                            return result;
                        } else {
                            ftp.changeWorkingDirectory(tempPath);
                        }
                    }
                }
            }
            // 设置上传文件的类型为二进制类型
            ftp.setFileType(FTP.BINARY_FILE_TYPE);
            // 上传文件
            if (!ftp.storeFile(filename, input)) {
                return result;
            }
            input.close();
            ftp.logout();
            result = true;
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (ftp.isConnected()) {
                try {
                    ftp.disconnect();
                } catch (IOException ioe) {
                }
            }
        }
        return result;
    }


    public static String getUsername() {
        return username;
    }

    public static void setUsername(String username) {
        FtpUtil.username = username;
    }

    public static String getPwd() {
        return pwd;
    }

    public static void setPwd(String pwd) {
        FtpUtil.pwd = pwd;
    }

    public static String getUPLOAD_PATH() {
        return UPLOAD_PATH;
    }

    public static void setUPLOAD_PATH(String uPLOAD_PATH) {
        UPLOAD_PATH = uPLOAD_PATH;
    }

    public static int getPort() {
        return port;
    }
    //

    // test
    public static void main(String[] args) {
        try {
            FileInputStream in = new FileInputStream(new File("C:\\Users\\zhaihl\\Pictures\\s1.jpg"));
            boolean flag = uploadFile("/test/uploadpic", "my.jpg", in);
            System.out.println(flag);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

}