如何实现ftp的文件上传于下载

    第一步准备一个ftp服务器；
    最基本的ftp文件夹下应该有public的文件和private的文件，一般公开的文件是直接从浏览器中访问的，而私有的文件是必须通过ftp的方式和下载，基于此逻辑，就需要给到http网址；
    第二步准备导入maven：

    1.         <dependency>
    2.             <groupId>commons-io</groupId>
    3.             <artifactId>commons-io</artifactId>
    4.             <version>2.4</version>
    5.         </dependency>

    第三步导入当前代码

    1. package com.yuxin.yijia.utils.ftp;
    3. import org.apache.commons.io.FileUtils;
    4. import org.apache.commons.net.ftp.FTP;
    5. import org.apache.commons.net.ftp.FTPClient;
    6. import org.apache.commons.net.ftp.FTPReply;
    7. import org.springframework.core.io.ClassPathResource;
    8. import org.springframework.core.io.Resource;
    9. import org.springframework.core.io.support.PropertiesLoaderUtils;
    11. import java.io.File;
    12. import java.io.FileInputStream;
    13. import java.io.IOException;
    14. import java.io.InputStream;
    15. import java.util.Properties;
    17. public class FileFtpUtil {
    19.     private String ftpIp;
    21.     private int port;
    22.     private String username;
    23.     private String password;
    24.     private String baseUrl;
    25.     private Resource resource = new ClassPathResource("yijia.properties");
    27.     private FileFtpUtil() {
    28.         //读取
    29.         try {
    30.             Properties props = PropertiesLoaderUtils.loadProperties(resource);
    31.             ftpIp = props.getProperty("ftpIp");
    32.             port = Integer.parseInt(props.getProperty("port", "21"));
    33.             username = props.getProperty("username");
    34.             password = props.getProperty("password");
    35.             baseUrl = props.getProperty("baseUrl", "/image");
    36.         } catch (Exception e) {
    37.             System.err.println("ftp配置初始化失败，原因：" + e);
    38.             e.printStackTrace();
    39.         }
    42.     }
    44.     public static FileFtpUtil getInstance() {
    45.         return Inner.instance;
    46.     }
    48.     private static class Inner {
    49.         private static final FileFtpUtil instance = new FileFtpUtil();
    50.     }
    53.     /**
    54.      * @param file     需要上传的文件
    55.      * @param filename 上传的----文件名.后缀  例：c.png 不带路径
    56.      * @param path     文件路径，如果没有此路径则会创建文件夹
    57.      * @throws IOException
    58.      */
    59.     public boolean picreate(File file, String filename, String path) throws IOException {
    60.         //创建一个FtpClient对象
    61.         FTPClient ftpClient = new FTPClient();
    62.         //创建ftp连接，默认是：21端口
    63.         ftpClient.connect(ftpIp, port);
    64.         //登录ftp服务器，使用用户名 和密码
    65.         ftpClient.login(username, password);
    66.         ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
    67.         int reply;
    68.         // 获取ftp登录应答代码
    69.         reply = ftpClient.getReplyCode();
    70.         // 验证是否登陆成功
    71.         if (!FTPReply.isPositiveCompletion(reply)) {
    72.             ftpClient.disconnect();
    73.             System.err.println("FTP server refused connection.");
    74.         }
    75.         //上传文件
    76.         //读取本地文件
    77.         FileInputStream inputStream = new FileInputStream(file);
    78.         //设置上传的路径
    79.         if (!path.startsWith("/"))
    80.             path = "/" + path;
    81.         if (!baseUrl.startsWith("/"))
    82.             baseUrl = "/" + baseUrl;
    83.         path = baseUrl + path;
    84.         // String fullpath = "ftp://" + ftpIp + ":" + port + path;
    85.         String d;
    86.         try {
    87.             //目录编码，解决中文路径问题
    88.             d = new String(path.toString().getBytes("GBK"), "iso-8859-1");
    89.             //尝试切入目录
    90.             if (!ftpClient.changeWorkingDirectory(d)) {
    91.                 String[] arr = path.split("/");
    92.                 StringBuffer sbfDir = new StringBuffer();
    93.                 //循环生成子目录
    94.                 for (String s : arr) {
    95.                     if (s == null || s.trim().equals(""))
    96.                         continue;
    97.                     sbfDir.append("/");
    98.                     sbfDir.append(s);
    99.                     //目录编码，解决中文路径问题
    100.                     d = new String(sbfDir.toString().getBytes("GBK"), "iso-8859-1");
    101.                     //尝试切入目录
    102.                     if (ftpClient.changeWorkingDirectory(d))
    103.                         continue;
    104.                     if (!ftpClient.makeDirectory(d)) {
    105.                         System.out.println("[失败]ftp创建目录：" + sbfDir.toString());
    106.                         ftpClient.logout();
    107.                         return false;
    108.                     }
    109.                     System.out.println("[成功]创建ftp目录：" + sbfDir.toString());
    110.                 }
    111.                 //将目录切换至指定路径
    112.                 if (!ftpClient.changeWorkingDirectory(d)) {//切换到指定目录
    113.                     ftpClient.logout();
    114.                     return false;
    115.                 }
    116.             }
    117.         } catch (Exception e) {
    118.             e.printStackTrace();
    119.             ftpClient.logout();
    120.             return false;
    121.         }
    122.         //修改上传文件的格式
    123.         //第一个参数：服务器端文档名
    124.         //第二个参数：上传文档的inputStream
    125.         boolean res = ftpClient.storeFile(filename, inputStream);
    126.         System.out.println("上传文件" + filename + ":" + res);
    127.         //关闭连接
    128.         ftpClient.logout();
    129.         return true;
    130.     }
    132.     /**
    133.      * @param httpUrl 文件的网络地址，请确定是上传到ftp上的文件
    134.      * @return
    135.      */
    136.     public boolean del4Http(String httpUrl) throws IOException {
    137.         //创建一个FtpClient对象
    138.         FTPClient ftpClient = new FTPClient();
    139.         //创建ftp连接，默认是：21端口
    140.         ftpClient.connect(ftpIp, port);
    141.         //登录ftp服务器，使用用户名 和密码
    142.         ftpClient.login(username, password);
    143.         ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
    144.         int reply;
    145.         // 获取ftp登录应答代码
    146.         reply = ftpClient.getReplyCode();
    147.         // 验证是否登陆成功
    148.         if (!FTPReply.isPositiveCompletion(reply)) {
    149.             ftpClient.disconnect();
    150.             System.err.println("FTP server refused connection.");
    151.         }
    152.         //设置上传的路径
    153.         if (!httpUrl.startsWith("http"))
    154.             return false;
    155.         String filePath = httpUrl.substring(httpUrl.indexOf(baseUrl));
    156.         if (!baseUrl.startsWith("/"))
    157.             baseUrl = "/" + baseUrl;
    158.         int index = filePath.lastIndexOf("/");
    159.         if (index == -1) {
    160.             System.err.println("文件路径异常：" + filePath);
    161.             ftpClient.logout();
    162.             return false;
    163.         }
    164.         String path = filePath.substring(0, index);
    165.         System.out.println(path);
    166.         if (!ftpClient.changeWorkingDirectory(path)) {//切换到指定目录
    167.             System.err.println("文件路径不存在：" + filePath);
    168.             ftpClient.logout();
    169.             return false;
    170.         }
    171.         System.out.println(filePath.substring(index + 1));
    172.         if (!ftpClient.deleteFile(filePath.substring(index + 1))) {
    173.             System.err.println("文件删除失败：" + filePath);
    174.             ftpClient.logout();
    175.             return false;
    176.         }
    177.         ftpClient.logout();
    178.         System.err.println("文件已删除：" + filePath);
    179.         return true;
    180.     }
    182.     public File download4Http(String httpUrl) throws IOException {
    183.         //创建一个FtpClient对象
    184.         FTPClient ftpClient = new FTPClient();
    185.         //创建ftp连接，默认是：21端口
    186.         ftpClient.connect(ftpIp, port);
    187.         //登录ftp服务器，使用用户名 和密码
    188.         ftpClient.login(username, password);
    189.         ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
    190.         int reply;
    191.         // 获取ftp登录应答代码
    192.         reply = ftpClient.getReplyCode();
    193.         // 验证是否登陆成功
    194.         if (!FTPReply.isPositiveCompletion(reply)) {
    195.             ftpClient.disconnect();
    196.             System.err.println("FTP server refused connection.");
    197.         }
    199.         if (!baseUrl.startsWith("/"))
    200.             baseUrl = "/" + baseUrl;
    201.         //设置上传的路径
    202. //        if (!httpUrl.startsWith("http"))
    203. //            return null;
    204.         int i = httpUrl.indexOf(baseUrl);
    205.         //如果上传路径中没有baseUrl，则应该是相对路径，则追加baseUrl
    206.         String filePath = null;
    207.         if (i == -1) {
    208.             filePath = baseUrl + httpUrl;
    209.         } else {
    210.             filePath = httpUrl.substring(i);
    211.         }
    213.         int index = filePath.lastIndexOf("/");
    214.         if (index == -1) {
    215.             System.err.println("文件路径异常：" + filePath);
    216.             ftpClient.logout();
    217.             ftpClient.disconnect();
    218.             return null;
    219.         }
    220.         String path = filePath.substring(0, index);
    221.         System.out.println(path);
    222.         if (!ftpClient.changeWorkingDirectory(path)) {//切换到指定目录
    223.             System.err.println("文件路径不存在：" + filePath);
    224.             ftpClient.logout();
    225.             ftpClient.disconnect();
    226.             return null;
    227.         }
    228.         String name = filePath.substring(index + 1);
    229.         System.out.println(name);
    230.         File file = new File(filePath.substring(index + 1));
    231.         if (ftpClient.retrieveFile(name, FileUtils.openOutputStream(file))) {
    232.             System.out.println("文件下载成功：" + path + ",length:" + file.length());
    233.             ftpClient.logout();
    234.             ftpClient.disconnect();
    235.             return file;
    236.         } else {
    237.             System.out.println("文件下载失败：" + path);
    238.             ftpClient.logout();
    239.             ftpClient.disconnect();
    240.             return file;
    241.         }
    242.         // ftpClient.enterLocalPassiveMode();  // 设置被动模式，开通一个端口来传输数据
    243.     }
    245.     /**
    246.      * 删除那种
    247.      *
    248.      * @param filePath
    249.      * @return
    250.      * @throws IOException
    251.      */
    252.     public boolean del(String filePath) throws IOException {
    253.         //创建一个FtpClient对象
    254.         FTPClient ftpClient = new FTPClient();
    255.         //创建ftp连接，默认是：21端口
    256.         ftpClient.connect(ftpIp, port);
    257.         //登录ftp服务器，使用用户名 和密码
    258.         ftpClient.login(username, password);
    259.         ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
    260.         int reply;
    261.         // 获取ftp登录应答代码
    262.         reply = ftpClient.getReplyCode();
    263.         // 验证是否登陆成功
    264.         if (!FTPReply.isPositiveCompletion(reply)) {
    265.             ftpClient.disconnect();
    266.             System.err.println("FTP server refused connection.");
    267.         }
    268.         //设置上传的路径
    269.         if (!filePath.startsWith("/"))
    270.             filePath = "/" + filePath;
    271.         if (!baseUrl.startsWith("/"))
    272.             baseUrl = "/" + baseUrl;
    273.         filePath = baseUrl + filePath;
    274.         int index = filePath.lastIndexOf("/");
    275.         if (index == -1) {
    276.             System.err.println("文件路径异常：" + filePath);
    277.             ftpClient.logout();
    278.             return false;
    279.         }
    280.         String path = filePath.substring(0, index);
    281.         System.out.println(path);
    282.         if (!ftpClient.changeWorkingDirectory(path)) {//切换到指定目录
    283.             System.err.println("文件路径不存在：" + filePath);
    284.             ftpClient.logout();
    285.             return false;
    286.         }
    287.         System.out.println(filePath.substring(index + 1));
    288.         if (!ftpClient.deleteFile(filePath.substring(index + 1))) {
    289.             System.err.println("文件删除失败：" + filePath);
    290.             ftpClient.logout();
    291.             return false;
    292.         }
    293.         ftpClient.logout();
    294.         System.err.println("文件已删除：" + filePath);
    295.         return true;
    296.     }
    298.     /**
    299.      * 判断某个文件(不是文件夹)存在吗
    300.      *
    301.      * @param filePath 文件或者文件夹路径
    302.      * @return
    303.      */
    304.     public boolean isExit(String filePath) throws IOException {
    305.         //创建一个FtpClient对象
    306.         FTPClient ftpClient = new FTPClient();
    307.         //创建ftp连接，默认是：21端口
    308.         ftpClient.connect(ftpIp, port);
    309.         //登录ftp服务器，使用用户名 和密码
    310.         ftpClient.login(username, password);
    311.         ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
    312.         int reply;
    313.         // 获取ftp登录应答代码
    314.         reply = ftpClient.getReplyCode();
    315.         // 验证是否登陆成功
    316.         if (!FTPReply.isPositiveCompletion(reply)) {
    317.             ftpClient.disconnect();
    318.             System.err.println("连接FTP SERVER失败，SERVER IP[" + ftpIp + port + "], Ftp response:" + ftpClient.getReplyString());
    319.             return false;
    320.         }
    321.         //设置上传的路径
    322.         if (!filePath.startsWith("/"))
    323.             filePath = "/" + filePath;
    324.         if (!baseUrl.startsWith("/"))
    325.             baseUrl = "/" + baseUrl;
    326.         filePath = baseUrl + filePath;
    327.         InputStream inputStream = ftpClient.retrieveFileStream(filePath);
    328.         if (inputStream == null || ftpClient.getReplyCode() == 550) {
    329.             System.out.println("FTP SERVER上未找到以下文件[" + filePath + "]");
    330.             return false;
    331.         }
    332.         ftpClient.logout();
    333.         return true;
    334.     }
    336.     public static void main(String[] args) {
    337.         // try {
    338.         // FileFtpUtil.picreate(new File("D:\\360MoveData\\Users\\sz\\Pictures\\Saved Pictures\\改革办平台整理2.png"), "/qinglu/888/fff.png");
    339.         // } catch (IOException e) {
    340.         //     e.printStackTrace();
    341.         // }
    343.         FileFtpUtil ftp = new FileFtpUtil();
    344.         // try {
    345.         //     ftp.del("/course/48996/20191111/0b16f709-1c5e-4b1d-a096-ad13b20c1f1b.jpg");
    346.         // } catch (IOException e) {
    347.         //     e.printStackTrace();
    348.         // }
    350.         try {
    351.             File file = ftp.download4Http("http://192.168.0.115/image/temp/48996/20191114/e3792e70-44e6-484b-a0f7-0690527f5185.jpg");
    352.             System.out.println(file.length());
    353.         } catch (IOException e) {
    354.             e.printStackTrace();
    355.         }
    356.         // try {
    357.         //     System.out.println(ftp.del4Http(path));
    358.         // } catch (IOException e) {
    359.         //     e.printStackTrace();
    360.         // }
    361.         //
    362.         // String sub = path.substring(path.indexOf("/image"));
    363.         // System.out.println(sub);
    364.     }
    365. }

    第四步：在Controller中调用此静态方法

    1. package com.yuxin.yijia.controller;
    3. import com.alibaba.fastjson.JSONArray;
    4. import com.alibaba.fastjson.JSONObject;
    5. import com.yuxin.wx.util.ToolStr;
    6. import com.yuxin.wx.utils.FileUtil;
    7. import com.yuxin.wx.utils.PropertiesUtil;
    8. import com.yuxin.wx.utils.WebUtils;
    9. import com.yuxin.yijia.utils.ftp.FileFtpUtil;
    10. import com.yuxin.yijia.utils.rest.ResultJson;
    11. import org.apache.commons.lang.ArrayUtils;
    12. import org.springframework.beans.factory.annotation.Autowired;
    13. import org.springframework.stereotype.Controller;
    14. import org.springframework.web.bind.annotation.RequestMapping;
    15. import org.springframework.web.bind.annotation.RequestMethod;
    16. import org.springframework.web.bind.annotation.ResponseBody;
    17. import org.springframework.web.multipart.MultipartFile;
    18. import org.springframework.web.multipart.MultipartRequest;
    20. import java.io.File;
    21. import java.io.IOException;
    22. import java.util.Iterator;
    24. @Controller
    25. public class FileController {
    27.     public static final String base = "/fileupload";
    28.     public static final String save = base + "/save";
    29.     public static final String up = base + "/up";
    30.     public static final String del = base + "/del";
    31.     public static final String get = base + "/get";
    34.     @Autowired
    35.     private PropertiesUtil propertiesUtil;
    38.     /**
    39.      * 实现删除旧的图片上传新的图片，而且还要保证其原子性，不考虑网络连接不稳定的情况（因为解决不了）
    40.      *
    41.      * @param multiPartRquest 上传的文件内容
    42.      * @param module          该文件对应的模块(根据其找到文件的前缀)
    43.      * @param oldPath         需要删除的文件，如果有路径的话携带路径
    44.      * @return
    45.      */
    46.     @ResponseBody
    47.     @RequestMapping(value = up, method = RequestMethod.POST)
    48.     public JSONObject upPic(MultipartRequest multiPartRquest, String module, String oldPath) throws IOException {
    49.         boolean flag = false;
    50.         //先看看是不是真的有原来的文件
    51.         try {
    52.             if (ToolStr.isEmpty(oldPath)) {
    53.                 return ResultJson.of(4000, "请传入原图片地址");
    54.             }
    55.             String basepath = propertiesUtil.getImageServicePath();
    56.             int basepathIndex = oldPath.indexOf(basepath);
    57.             oldPath = oldPath.substring(basepathIndex + basepath.length());
    58.             if (FileFtpUtil.getInstance().isExit(oldPath)) {
    59.                 flag = true;
    60.             }
    61.         } catch (IOException e) {
    62.             e.printStackTrace();
    63.         }
    64.         //监控一下是不是只有一个文件
    65.         if (multiPartRquest.getFileMap().size() > 1) {
    66.             return ResultJson.of(4000, "只能上传1个文件");
    67.         }
    68. //        System.out.println(multiPartRquest.getMultiFileMap().size());
    69. //        System.out.println(multiPartRquest.getFileMap().size());
    70.         if (flag) {
    71.             flag = false;
    72.             //如果是有则开始进行文件上传
    73.             JSONObject res = null;
    74.             try {
    75.                 res = uploadFile(multiPartRquest, getPrefix(module));
    76.                 if (res.getInteger("code") == 200) {
    77.                     flag = true;
    78.                 }
    79.             } catch (IOException e) {
    80.                 e.printStackTrace();
    81.             }
    82.             //文件上传成功后则执行删除 oldPath
    83.             if (flag) {
    84.                 flag = false;
    85.                 try {
    86.                     if (FileFtpUtil.getInstance().del(oldPath)) {
    87.                         flag = true;
    88.                         return res;
    89.                     } else {
    90.                         System.err.println("FTP:删除文件" + oldPath + "异常");
    91.                         return res;
    92.                     }
    93.                 } catch (IOException e) {
    94.                     e.printStackTrace();
    95.                 }
    96.                 if (!flag) {
    97.                     //如果删除失败则需要再删除新上传的图片
    98.                     JSONObject data = res.getJSONObject("data");
    99.                     if (data != null) {
    100.                         String url = data.getString("url");
    101.                         if (url != null) {
    102.                             boolean ok = FileFtpUtil.getInstance().del(url);//删除新上传的文件
    103.                             if (ok) {
    104.                                 return ResultJson.of(4002, "文件上传成功后删除失败，已成功回滚");
    105.                             } else {
    106.                                 return ResultJson.of(4002, "文件上传成功后删除失败，回滚失败，新文件已上传");
    107.                             }
    108.                         }
    109.                     }
    110.                     return ResultJson.of(4002, "文件上传成功后删除失败，回滚失败，新文件已上传");
    111.                 } else {
    112.                     return res;
    113.                 }
    114.             } else {
    115.                 return ResultJson.of(4001, "文件上传异常");
    116.             }
    117. //            return ResultJson.of(4001, "文件上传异常");
    118.         } else {
    119.             return ResultJson.of(4000, "oldPath不存在");
    120.         }
    121.     }
    123.     /**
    124.      * 获取前缀
    125.      *
    126.      * @param module
    127.      */
    128.     private String getPrefix(String module) {
    129.         if (ToolStr.isEmpty(module)) {
    130.             module = FileUtil.Module.TEMP;
    131.         }
    132.         return FileUtil.getPath(module, WebUtils.getCurrentCompanyId().toString());
    133.     }
    136.     /**
    137.      * FTP上传图片，保存图片
    138.      *
    139.      * @param multiPartRquest 上传的文件
    140.      * @param module          （分类）模块名称参考下面的类,如果传空默认是temp类型
    141.      * @return
    142.      * @see FileUtil.Module
    143.      */
    144.     @ResponseBody
    145.     @RequestMapping(value = save, method = RequestMethod.POST)
    146.     public JSONObject queryPic(MultipartRequest multiPartRquest, String module) {
    147.         if (ToolStr.isEmpty(module)) {
    148.             module = FileUtil.Module.TEMP;
    149.         }
    150.         String path = FileUtil.getPath(module, WebUtils.getCurrentCompanyId().toString());
    151.         //         String contentType = mfile.getContentType();
    152.         //         String checkExcelFileType = checkExcelFileType(contentType);
    153.         try {
    154.             return uploadFile(multiPartRquest, path);
    155.         } catch (IOException e) {
    156.             e.printStackTrace();
    157.             return ResultJson.of(4000, "文件上传异常");
    158.         }
    159.     }
    161.     public static final String[] File_Type = {"default", "xlsx", "xls", "doc", "docx", "ppt", "pptx", "pdf", "txt", "zip", "rar", "png", "jpg", "jpeg",
    162.             "3gp", "avi", "flv", "mp4", "mkv", "mov", "ogg", "wmv", "gif", "del", "", "", "", "", ""};
    164.     /**
    165.      * 文件类型是不是对应的文件
    166.      *
    167.      * @param contentType
    168.      * @return
    169.      */
    170.     // 判断文件类型
    171.     public static boolean checkFileType(String contentType) {
    172.         int a = contentType.indexOf(".");
    173.         if (a != -1) {
    174.             return ArrayUtils.contains(File_Type, contentType);
    175.         } else {
    176.             String str = contentType.substring(a, contentType.length());
    177.             return ArrayUtils.contains(File_Type, str);
    178.         }
    179.     }
    182.     // 判断文件类型
    183.     public static String checkExcelFileType(String contentType) {
    184.         switch (contentType) {
    185.             case "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":
    186.                 return ".xlsx";
    187.             case "application/vnd.ms-excel":
    188.                 return ".xls";
    189.             case "application/msword":
    190.                 return ".doc";
    191.             case "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
    192.                 return ".docx";
    193.             case "application/pdf":
    194.                 return ".pdf";
    195.             case "text/plain":
    196.                 return ".txt";
    197.             case "application/zip":
    198.                 return ".zip";
    199.             case "application/octet-stream":
    200.                 return ".rar";
    201.             case "application/x-png":
    202.                 return ".png";
    203.             case "image/png":
    204.                 return ".png";
    205.             case "application/x-jpg":
    206.                 return ".jpg";
    207.             case "image/jpeg":
    208.                 return ".jpeg";
    209.             case "video/3gpp":
    210.                 return ".3gp";
    211.             case "video/x-msvideo":
    212.                 return ".avi";
    213.             case "video/x-flv":
    214.                 return ".flv";
    215.             case "video/mp4":
    216.                 return ".mp4";
    217.             case "video/x-matroska":
    218.                 return ".mkv";
    219.             case "video/quicktime":
    220.                 return ".mov";
    221.             case "video/x-theora+ogg":
    222.                 return ".ogg";
    223.             case "video/x-ms-wmv":
    224.                 return ".wmv";
    225.             case "image/gif":
    226.                 return ".gif";
    227.         }
    228.         return "";
    229.     }
    231.     /**
    232.      * 实现文件上传到ftp
    233.      *
    234.      * @param multiPartRquest 携带文件的对象
    235.      * @param prefix          文件的路径（前缀）
    236.      * @return
    237.      * @throws IOException
    238.      */
    239.     private JSONObject uploadFile(MultipartRequest multiPartRquest, String prefix) throws IOException {
    240.         JSONObject data = new JSONObject();
    241.         JSONArray arr = new JSONArray();
    242.         Iterator iter = multiPartRquest.getFileNames();
    243.         while (iter.hasNext()) {
    244.             MultipartFile multipartFile = multiPartRquest.getFile(iter.next().toString());
    245.             // MultipartFile multipartFile = multiPartRquest.getFile("imgData");
    246.             //被注释掉的是老的使用方式
    247.             // String realPath = null;
    248.             // realPath = FileUtil.upload(multipartFile, "temp", WebUtils.getCurrentCompanyId()+"");
    250.             //通过ftp方式上传图片或者文件
    251.             String fileName = FileUtil.generateFileName(multipartFile.getOriginalFilename());
    252.             if (checkFileType(fileName)) {
    253.                 return ResultJson.of(4001, "文件类型异常");
    254.             }
    255.             File file = new File(fileName);
    256.             // file = File.createTempFile("/qinglu/a/", ".jpg");
    257.             multipartFile.transferTo(file);
    258.             FileFtpUtil.getInstance().picreate(file, fileName, prefix);
    259.             // FileFtpUtil.picreate(multipartFile.getInputStream(), path + fileName);
    260.             file.deleteOnExit();//程序退出时删除临时文件
    261.             //上传文件
    262.             // req.getSession().setAttribute("imgData", multipartFile);
    263.             String url = "/" + prefix + fileName;
    264.             arr.add(url);
    265.         }
    266.         if (arr.size() == 0) {
    267.             return ResultJson.of(4000, "没有任何文件上传");
    268.         }
    269.         //判断是不是一个文件
    270.         if (arr.size() == 1) {
    271.             data.put("url", arr.get(0));
    272.         } else {
    273.             //如果是多个文件放到list中
    274.             data.put("list", arr);
    275.         }
    276.         return ResultJson.of(200, data);
    277.     }
    278. }

    如此即可实现上传和下载