springboot 结合fastdfs

加入依赖

		<dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
        </dependency>

工具类

public class FastdfsUtil {
   // trackerUrl 服务器地址  multipartFile 上传的文件
    public static FileDto uploadFile(String trackerUrl, MultipartFile multipartFile) throws IOException, MyException {
        // 根据url 初始化ClientGlobal
        ClientGlobal.initByTrackers(trackerUrl);
        TrackerClient trackerClient = new TrackerClient();
        TrackerServer trackerServer = trackerClient.getTrackerServer();
        StorageServer storageServer = trackerClient.getStoreStorage(trackerServer);
        StorageClient1 client = new StorageClient1(trackerServer, storageServer);

        String fileName = multipartFile.getOriginalFilename();
        String fileExtName = fileName.substring(fileName.lastIndexOf(".") + 1);
        NameValuePair[] metaList = new NameValuePair[3];
        // 保存文件名
        metaList[0] = new NameValuePair("fileName", fileName);
        //文件格式
        metaList[1] = new NameValuePair("fileExtName", fileExtName);
        metaList[2] = new NameValuePair("fileLength", String.valueOf(multipartFile.getBytes().length));

        String fileId = client.upload_file1(multipartFile.getBytes(), fileExtName, metaList);
        FileDto fileDto = new FileDto();
        fileDto.setFileUrl(fileId);
        fileDto.setFileName(fileName);
        return fileDto;
    }
    public static FastdfsFileInfo download(String trackerUrl, String fileId) throws IOException, MyException {
        ClientGlobal.initByTrackers(trackerUrl);
        TrackerClient trackerClient = new TrackerClient();
        TrackerServer trackerServer = trackerClient.getTrackerServer();
        StorageServer storageServer = trackerClient.getStoreStorage(trackerServer);
        StorageClient1 client = new StorageClient1(trackerServer, storageServer);
        byte[] bytes = client.download_file1(fileId);
        if (bytes == null) {
            return new FastdfsFileInfo();
        }
        NameValuePair[] metadata1 = client.get_metadata1(fileId);
        return new FastdfsFileInfo(bytes, metadata1);
    }
    @Data
    @NoArgsConstructor
    public static class FastdfsFileInfo {

        private byte[] file;

        private String fileName;

        private String fileExtName;

        private String fileLength;

        public Boolean fileExist() {
            return file != null;
        }

        public FastdfsFileInfo(byte[] file, NameValuePair[] metaList) {
            this.file = file;
            if (metaList != null) {
                for (NameValuePair nameValuePair : metaList) {
                    switch (nameValuePair.getName()) {
                        case "fileName":
                            this.fileName = nameValuePair.getValue();
                            break;
                        case "fileExtName":
                            this.fileExtName = nameValuePair.getValue();
                            break;
                        case "fileLength":
                            this.fileLength = nameValuePair.getValue();
                            break;
                        default:
                            break;
                    }
                }
            }
        }
    }
}

根据fastdfs的url 打包下载文件

public class ZipUtil {
    public static String serverUrl = "xx.xx.xx.xx:22122";
    public static HttpServletResponse downLoadFiles(List<String> files, HttpServletResponse response,String etpName,HttpServletRequest request)throws Exception {
        try {
            //List<File> 作为参数传进来，就是把多个文件的路径放到一个list里面

            //创建一个临时压缩文件

            //临时文件可以放在CDEF盘中，但不建议这么做，因为需要先设置磁盘的访问权限，最好是放在服务器上，方法最后有删除临时文件的步骤
			// 生成临时的文件名
            String zipFilename =  "/usr/local/sti/"+etpName+".zip" ;
            File file = new File(zipFilename);
            if (!file.exists()){
                file.createNewFile();
            }
            //response.getWriter()
            //创建文件输出流
            FileOutputStream fous = new FileOutputStream(file);
            ZipOutputStream zipOut = new ZipOutputStream(fous);
            zipFile(files, zipOut);
            zipOut.close();
            fous.close();
            return downloadZip(file,response,request);
        }catch (Exception e) {
            e.printStackTrace();
        }
        return response ;
    }

    /**
     * 把接受的全部文件打成压缩包
     *
     */
    public static void zipFile (List<String> files,ZipOutputStream outputStream) {
     
        for(String file ： files) {
            zipFile(file, outputStream);
        }

    }
    /**
     * 根据输入的文件与输出流对文件进行打包
     *
     */
    public static void zipFile(String inputFile,  ZipOutputStream ouputStream) {
        try {
           
            FastdfsUtil.FastdfsFileInfo download = FastdfsUtil.download(serverUrl, inputFile);
//            String fileName = (String) inputFile.getValue();
//            File file = new File(url);
            if(download.fileExist()) {
                byte[] file = download.getFile();

                Random random = new Random();
                // 方式出现重名的文件
                ZipEntry entry = new ZipEntry(random.nextInt(10)+download.getFileName());

                    ouputStream.putNextEntry(entry);
                    // 向压缩文件中输出数据
                        ouputStream.write(file);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    // 下载文件
    public static HttpServletResponse downloadZip(File file, HttpServletResponse response, HttpServletRequest request) {
        if (file.exists() == false) {
            log.error("待压缩的文件目录：" + file + "不存在.");
        } else {
            try {
                // 以流的形式下载文件。
                InputStream fis = new BufferedInputStream(new FileInputStream(file.getPath()));
                byte[] buffer = new byte[fis.available()];
                fis.read(buffer);
                fis.close();
                // 清空response


                OutputStream toClient = new BufferedOutputStream(response.getOutputStream());
                response.setContentType("application/octet-stream");
                String userAgent = request.getHeader("User-Agent");
                String fileName = null;
                if (userAgent.contains("MSIE") || userAgent.contains("Trident")) {
                    fileName = URLEncoder.encode(file.getName(), "UTF-8");
                } else {
                    // 非IE浏览器的处理：
                    fileName = new String(file.getName().getBytes("UTF-8"), "ISO-8859-1");
                }
                //如果输出的是中文名的文件，在此处就要用URLEncoder.encode方法进行处理
                response.setHeader("Content-Disposition", "attachment;filename="
                        + fileName);
                toClient.write(buffer);
                toClient.flush();
                toClient.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            } finally {
                try {
                    File f = new File(file.getPath());
                    f.delete();
                } catch (Exception e) {
                    log.info("压缩文件失败");
                    e.printStackTrace();
                }
            }
        }
        return response;
    }

    public static void downCfg(String fileName, HttpServletRequest request, HttpServletResponse response) throws UnsupportedEncodingException {

        // 判断浏览器，进行不同的加密，这样下载的时候保存的文件名就不会乱码
        String userAgent = request.getHeader("User-Agent");
        // 针对IE或者以IE为内核的浏览器：
        if (userAgent.contains("MSIE") || userAgent.contains("Trident")) {
            fileName = URLEncoder.encode(fileName, "UTF-8");
        } else {
            // 非IE浏览器的处理：
            fileName = new String(fileName.getBytes("UTF-8"), "ISO-8859-1");
        }
        response.setHeader("Content-disposition", String.format("attachment; filename=\"%s\"", fileName));
        response.setContentType("application/octet-stream;charset=utf-8");
        response.setCharacterEncoding("UTF-8");
    }
}