FTP-读取指定目录下的文件，上传到FTP服务器，一键复制黏贴，就是这么丝滑~

已于 2023-08-11 11:18:35 修改
阅读量745 收藏 1
点赞数
分类专栏： 运行环境 文章标签： 服务器 运维
于 2023-06-29 15:37:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43511677/article/details/131457358
版权

背景：需要定时将服务器下的日志文件上传到指定FTP服务器的目录下，并通知第三方平台文件已上传。

FTP服务器模拟工具：

 application.yml配置：

spring:
  logfilepath: /home/jboss/server/default/log
  # ftp配置
  ftp:
    ip: 192.*****
    port: 21
    username: root
    password: 123456
    path: /FtpRoot/ZZDT12/
    subsystem: CCTV/
  # 智能运维平台配置
  znyw:
    # ftp文件上传后通知智能运维系统地址
    filestatusurl: http://***:7000/imaster/log/upload
    # 日志文件每天 23 点 58 分执行上传、通知智能运维平台一次
    scan: "0 58 23 * * ?"
    # 线路编码
    lineid: 12
    # 子系统编码
    subsystemid: 10
  servlet:
    multipart:
      enabled: true
      # 根据实际需求作调整
      max-file-size: -1
      max-request-size: -1

定时任务：

import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.vcom.nms.service.IFileUploadService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.mock.web.MockMultipartFile;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.List;

/**
 * 运维对接-日志文件上报接口
 */
@Configuration
public class LogFilePushTask extends BaseTask {

    private static final Logger logger = LoggerFactory.getLogger(LogFilePushTask.class);

    @Autowired
    private IFileUploadService fileUploadService;

    @Value("${spring.logfilepath}")
    private String SYS_LOG_FILE_PATH;

    /**
     * 日志文件每天 23 点 58 分执行上传、通知智能运维平台一次
     */
    @Scheduled(cron = "${spring.znyw.scan}")
    private void fileUploadTask() {
        logger.info("============come in fileUploadTask============");
        List<MultipartFile> multipartFileList = new ArrayList<>();
        try {
            multipartFileList = getFilesAsMultipart(SYS_LOG_FILE_PATH);
        } catch (IOException e) {
            logger.error("io Exc:", e);
        } catch (Exception e) {
            logger.error("Exc:", e);
        }
        logger.info("此次上传文件共：" + multipartFileList.size());
        multipartFileList.forEach(file -> {
            String fileName = fileUploadService.uploadFileAndNotice(file);
            if (StringUtils.isNotBlank(fileName)) {
                logger.info("成功上传日志文件：" + fileName);
            }
        });
    }

    public static List<MultipartFile> getFilesAsMultipart(String directoryPath) throws IOException {
        List<MultipartFile> multipartFiles = new ArrayList<>();
        File directory = new File(directoryPath);
        File[] files = directory.listFiles();
        for (File file : files) {
            multipartFiles.add(convertToMultipart(file));
        }
        return multipartFiles;
    }

    private static MultipartFile convertToMultipart(File file) throws IOException {
        byte[] fileContent = Files.readAllBytes(file.toPath());
        return new MockMultipartFile(file.getName(), file.getName(), "text/plain", fileContent);
    }

}

接口类：

import org.springframework.web.multipart.MultipartFile;

import java.util.List;

public interface IFileUploadService {
    /**
     * @Description:  上传文件到ftp服务器并通知智能运维平台
     * @param file
     * @return:
     * @Author: hyh
     * @Date: 2023/4/19 9:19
     */
    String uploadFileAndNotice(MultipartFile file);

    /**
     * @Description:  通知智能运维平台文件上传
     * @param fileName
     * @return:
     * @Author: hyh
     * @Date: 2023/4/19 11:13
     */
    void noticZnywFileStatus(String fileName);

    /**
     * @Description:  根据文件名称查看是否成功上传
     * @param fileName
     * @return:
     * @Author: hyh
     * @Date: 2023/4/19 13:28
     */
    List getFileNameList(String fileName);
}

工具类FtpUtil：

package com.vcom.nms.utils;


import com.vcom.nms.config.FtpConfig;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPFile;
import org.apache.commons.net.ftp.FTPReply;
import org.springframework.stereotype.Component;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.file.Files;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Description:  FtpUtil工具类
 * @return:
 * @Author: hyh
 * @Date: 2023/4/18 15:11
 */
@Slf4j
@Component
@RequiredArgsConstructor
public class FtpUtil {

    private final FtpConfig ftpConfig;

    private static final String DIR_SPLIT = "/";

    /**
     * 获取 FTPClient
     *
     * @return FTPClient
     */
    private FTPClient getFTPClient() {
        FTPClient ftpClient = ftpConfig.connect();
        if (ftpClient == null || !FTPReply.isPositiveCompletion(ftpClient.getReplyCode())) {
            throw new RuntimeException("ftp客户端异常");
        }
        return ftpClient;
    }

    /**
     * 获取FTP某一特定目录下的所有文件名称
     *
     * @param ftpDirPath FTP上的目标文件路径
     */
    public List<String> getFileNameList(String ftpDirPath) {
        FTPClient ftpClient = getFTPClient();
        try {
            // 通过提供的文件路径获取 FTPFile 文件列表
            // FTPFile[] ftpFiles = ftpClient.listFiles(ftpDirPath, FTPFile::isFile); // 只获取文件
            // FTPFile[] ftpFiles = ftpClient.listFiles(ftpDirPath, FTPFile::isDirectory); // 只获取目录
            FTPFile[] ftpFiles = ftpClient.listFiles(ftpDirPath);
            if (ftpFiles != null && ftpFiles.length > 0) {
                return Arrays.stream(ftpFiles).map(FTPFile::getName).collect(Collectors.toList());
            }
            log.error(String.format("路径有误，或目录【%s】为空", ftpDirPath));
        } catch (IOException e) {
            log.error("文件获取异常:", e);
        } finally {
            try {
                if (ftpClient.isConnected()) {
                    ftpClient.logout();
                    ftpClient.disconnect();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    /**
     * 上传文件
     *
     * @param uploadPath 上传路径
     * @param fileName   文件名
     * @param input      文件输入流
     * @return 上传结果
     */
    public boolean upload(String uploadPath, String fileName, InputStream input) {
        FTPClient ftpClient = getFTPClient();
        try {
            //把文件转换为二进制字符流的形式进行上传
            ftpClient.setFileType(ftpClient.BINARY_FILE_TYPE);
            createDir(ftpClient, uploadPath);
            // 文件写入
            boolean storeFile = ftpClient.storeFile(fileName, input);
            if (storeFile) {
                log.info("文件:{}上传成功", fileName);
            } else {
                throw new RuntimeException("ftp文件写入异常");
            }
            ftpClient.logout();
            return true;
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (input != null) {
                    input.close();
                }
                if (ftpClient.isConnected()) {
                    ftpClient.disconnect();
                }
            } catch (IOException ioe) {
                ioe.printStackTrace();
            }
        }
        return false;
    }

    // 创建文件夹，并切换到该文件夹
    // 比如： hello/test
    //最终会切换到test 文件夹返回
    private void createDir(FTPClient client, String path) throws IOException {
        String[] dirs = path.split("/");
        for (String dir : dirs) {
            if (StringUtils.isEmpty(dir)) {
                continue;
            }
            if (!client.changeWorkingDirectory(dir)) {
                client.makeDirectory(dir);
            }
            client.changeWorkingDirectory(dir);
        }
    }
    /**
     * 下载文件 *
     *
     * @param ftpPath     FTP服务器文件目录 *
     * @param ftpFileName 文件名称 *
     * @param localPath   下载后的文件路径 *
     * @return
     */
    public boolean download(String ftpPath, String ftpFileName, String localPath) {
        FTPClient ftpClient = getFTPClient();
        OutputStream outputStream = null;
        try {
            FTPFile[] ftpFiles = ftpClient.listFiles(ftpPath, file -> file.isFile() && file.getName().equals(ftpFileName));
            if (ftpFiles != null && ftpFiles.length > 0) {
                FTPFile ftpFile = ftpFiles[0];
                File localFile = new File(localPath + DIR_SPLIT + ftpFile.getName());
                // 判断本地路径目录是否存在，不存在则创建
                if (!localFile.getParentFile().exists()) {
                    localFile.getParentFile().mkdirs();
                }
                outputStream = Files.newOutputStream(localFile.toPath());
                ftpClient.retrieveFile(ftpFile.getName(), outputStream);

                log.info("fileName:{},size:{}", ftpFile.getName(), ftpFile.getSize());
                log.info("下载文件成功...");
                return true;
            } else {
                log.info("文件不存在，filePathname:{},", ftpPath + DIR_SPLIT + ftpFileName);
            }
        } catch (Exception e) {
            log.error("下载文件失败...");
            e.printStackTrace();
        } finally {
            try {
                if (outputStream != null) {
                    outputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (ftpClient.isConnected()) {
                    ftpClient.logout();
                    ftpClient.disconnect();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return false;
    }

    /**
     * 从FTP服务器删除文件或目录
     * 存在文件的目录无法删除
     *
     * @param ftpPath  服务器文件存储路径
     * @param fileName 服务器文件存储名称
     * @return 删除结果
     */
    public boolean delete(String ftpPath, String fileName) {
        FTPClient ftpClient = getFTPClient();
        try {
            // 在 ftp 目录下获取文件名与 fileName 匹配的文件信息
            FTPFile[] ftpFiles = ftpClient.listFiles(ftpPath, file -> file.getName().equals(fileName));
            // 删除文件
            if (ftpFiles != null && ftpFiles.length > 0) {
                boolean del;
                String deleteFilePath = ftpPath + DIR_SPLIT + fileName;
                FTPFile ftpFile = ftpFiles[0];
                if (ftpFile.isDirectory()) {
                    del = ftpClient.removeDirectory(deleteFilePath);
                } else {
                    del = ftpClient.deleteFile(deleteFilePath);
                }
                log.info(del ? "文件:{}删除成功" : "文件:{}删除失败", fileName);
                return del;
            } else {
                log.warn("文件:{}未找到", fileName);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (ftpClient.isConnected()) {
                    ftpClient.logout();
                    ftpClient.disconnect();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return false;
    }

    /**
     * 判断文件大小
     *
     * @param len
     *            文件长度
     * @param size
     *            限制大小
     * @param unit
     *            限制单位（B,K,M,G）
     * @return
     */
    public static boolean checkFileSize(Long len, int size, String unit) {
        double fileSize = 0;
        if ("B".equals(unit.toUpperCase())) {
            fileSize = (double) len;
        } else if ("K".equals(unit.toUpperCase())) {
            fileSize = (double) len / 1024;
        } else if ("M".equals(unit.toUpperCase())) {
            fileSize = (double) len / 1048576;
        } else if ("G".equals(unit.toUpperCase())) {
            fileSize = (double) len / 1073741824;
        }
        if (fileSize > size) {
            return false;
        }
        return true;
    }
}

 

接口实现类：

import java.io.IOException;
import java.io.InputStream;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

@Service
public class FileUploadServiceImpl implements IFileUploadService {
    private static final Logger logger = LoggerFactory.getLogger(FileUploadServiceImpl.class);

    @Autowired
    private final FtpUtil ftpUtil;
    @Value("${spring.ftp.path}")
    private String FTP_ROOT_DIR;
    @Value("${spring.ftp.subsystem}")
    private String SUBSYSTEM_NAME;
    @Value("${spring.znyw.filestatusurl}")
    private String ZNYW_FILE_STATUS_URL;
    @Value("${spring.znyw.lineid}")
    private int ZNYW_LINEID;
    @Value("${spring.znyw.subsystemid}")
    private int ZNYW_SUBSYSTEMID;

    private FileUploadServiceImpl(FtpUtil ftpUtil) {
        this.ftpUtil = ftpUtil;
    }

    @Override
    public String uploadFileAndNotice(MultipartFile file) {
        if (!ftpUtil.checkFileSize(file.getSize(), 100, "M")) {
            logger.warn("文件{}大小超过100MB，不予上传！", file.getOriginalFilename());
            return null;
        }
        String fileName = "";
        try {
            // 读取文件信息
            String name = file.getOriginalFilename();
            InputStream fileInputStream = file.getInputStream();
            //年月日
            LocalDate date = LocalDate.now();
            DateTimeFormatter formatter1 = DateTimeFormatter.ofPattern("yyyyMMdd");
            DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyy_MM_dd");
            fileName = date.format(formatter2) + "_" + name;
            // 上传文件到 Ftp 服务
            boolean flag = ftpUtil.upload(FTP_ROOT_DIR + SUBSYSTEM_NAME + date.format(formatter1), fileName, fileInputStream);
            //通知智能运维平台
            if (!(flag && syncMsgToZnywPlatform(fileName))) {
                logger.error(flag + ":{}文件上传失败！", file.getOriginalFilename());
                return null;
            }
        } catch (IOException e) {
            logger.error("文件上传失败！", String.valueOf(e));
        }
        return fileName;
    }

    @Override
    public void noticZnywFileStatus(String fileName) {
        syncMsgToZnywPlatform(fileName);
    }

    @Override
    public List getFileNameList(String fileName) {
        Pattern pattern = Pattern.compile("\\d{4}_\\d{2}_\\d{2}");
        Matcher matcher = pattern.matcher(fileName);
        String directory = "";
        if (matcher.find()) {
            directory = matcher.group().replace("_", "");
        } else {
            throw new RuntimeException("文件名称格式不正确！");
        }
        String path = FTP_ROOT_DIR + SUBSYSTEM_NAME + directory;
        return ftpUtil.getFileNameList(path);
    }

    //同步ftp文件上传信息到智能运维平台
    public boolean syncMsgToZnywPlatform(String fileName) {
        Response response = null;
        long timestamp = System.currentTimeMillis();
        try {
            OkHttpClient client = new OkHttpClient().newBuilder()
                    .connectTimeout(15, TimeUnit.SECONDS)
                    .readTimeout(15, TimeUnit.SECONDS)
                    .writeTimeout(15, TimeUnit.SECONDS)
                    .build();
            MediaType mediaType = MediaType.parse("text/plain");
            RequestBody body = RequestBody.create(mediaType, "");
            Request request = new Request.Builder()
                    .url(ZNYW_FILE_STATUS_URL + "?lineId=" + ZNYW_LINEID + "&systemId=" + ZNYW_SUBSYSTEMID + "&fileName=" + fileName)
                    .method("POST", body)
                    .addHeader("Content-Type", "application/json")
                    .build();
            response = client.newCall(request).execute();
            if (response.isSuccessful()) {
                String res = response.body().string();
                logger.info("操作：通知智能运维系统，请求客户端返回信息：{}", res);
                return true;
            }
        } catch (Exception e) {
            logger.error("IOException={}", e.getMessage());
            return false;
        } finally {
            if (null != response) {
                response.close();
            }
            logger.info("fileStatusUpload_time:" + (System.currentTimeMillis() - timestamp));
        }
        return false;
    }
}

草莓不苦
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用批处理上传文件到ftp目录下的实现方法
09-21
主要介绍了用批处理上传文件到ftp目录下的实现方法的相关内容，非常不错具有参考借鉴价值，感兴趣的朋友一起看下吧
ftp怎么上传文件至指定的目录_ftp上传工具下载，ftp上传工具下载使用教程，Windows Server如何搭建ftp服务器？...
weixin_39917090的博客
11-30 1092
ftp下载工具简介iis7远程桌面管理软件，是一款绿色小巧，功能实用的ftp软件，其界面简洁，操作方便，它支持FTP批量上传下载，它可以同时连接多台ftp服务器进行文件传输工作，还可以在线解压缩文件，支持文件查找，在线编辑等功能。1. ftp下载工具使用教程**下载地址：IIS7服务器管理工具添加ftp服务器信息 第一步：点击主程序图中“上传下载”键； 第二步：点击“ Ftp”； 第三步：点击“添...
JAVA FTPClient文件操作
梦想起飞的地方.........
02-21 2869
ftp
获取FTP服务器某个目录下的所有文件列表
aCupOfGelato的博客
04-04 3575
定时调用逻辑使用的是PowerJob, 嫌麻烦可以直接使用spring自带的@Scheduled注解.最近的一个需求为扫描FTP文件夹下的所有文件用于前端下载, 要求多层文件夹内的文件也能被扫到.调用完后, fileList中就有指定目录下的所有文件名。
Java ftp获取单个文件
qq_43072912的博客
12-29 496
java ftp获取单个文件并解析
FtpClient获取数据实例
高考我军的博客
11-23 1611
实际项目中有一个需求：将远程服务器上的文件转存到本地服务器，开发中遇到很多问题，总结出一个可行的代码实例。
java FTPClient类 连接ftp 根据自己想匹配文字取出文件名
weixin_44447963的博客
10-29 1172
博主也很菜???? 需要jar包 commons-net-3.6.jar 地址 http://commons.apache.org/proper/commons-net/download_net.cgi /** * 获取FTP文件名字 * @param ftpClient 连接ftp * @param hostName ip地址 * @param port 端口 * @param userName 用户
Java FTP 指定下载文件和上传文件到指定的服务器目录
09-14
已经测试 完全没问题 大可以满足你的简单需求 修改液很容易 里面有详细的注释说明
JAVA技术实现上传下载文件到FTP服务器(完整)
09-03
在Java编程中，实现文件的上传和下载至FTP服务器是一项常见的任务，这通常涉及到网络通信和文件处理。Apache Jakarta Commons Net库提供了一种简洁而强大的方式来处理FTP操作。在这个场景中，`FavFTPUtil`类展示了...
上传本地文件夹的文件到FTP服务器指定目录
07-14
在IT行业中，文件传输是日常...总之，上传本地文件夹的文件到FTP服务器指定目录是一个涉及FTP协议、C#编程和文件系统操作的综合任务。通过理解这些知识点，结合实际项目需求，可以创建一个高效且安全的文件上传工具。
java 通过ftp读取某个路径下的所有文件内容
u010479989的博客
06-19 2992
/ 设置文件传输模式为二进制。// 连接到FTP服务器。
c# SftpHelper 安全文件传输
北京-老黑的博客
12-19 1169
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using Renci.SshNet; using System.IO; using System.Threading; using System.Net; /****...
Java第十一篇：FTPClient将指定目录下的文件批量复制到另一个目录下
专注分享个人所得，希望给大家带来帮助
05-23 2776
FtpClient的复制功能实现 /** * 将指定文件目录下的多个文件复制到另一个指定文件中 * @param fileNames 要复制的文件名 * @param fromPath 从哪个文件目录中复制 * @param toPath 复制到哪个目录 * @return true-复制成功，false-复制失败 * @throws IOException */ public boolean batchCopyFileToPath(List<String> fileNames, String
java通过FTPClient实现文件在指定文件夹的上传下载
u013225974的博客
07-28 7079
文章转载： 文件上传下载：https://www.cnblogs.com/yingyujyf/p/6933823.html 创建目录：https://blog.csdn.net/weixin_40582761/article/details/87185007 目录绝对路径相对路径：https://blog.csdn.net/mqdxiaoxiao/article/details/107463378 通过FTPClient对象操作上传下载需要引入jar包commons-net-1.4.1.jar，
BAT&PowerShell实现本地文件自动上传FTP服务器
par@ish的博客
08-22 2713
另外，考虑到安全性，避免在批处理文件中明文写入密码，最好是使用安全的方式来存储和传递敏感信息。使用批处理（BAT）命令文件将本地文件夹内容上传到FTP服务器需要使用Windows自带的命令行工具，如ftp命令。首先，你需要创建一个新的文本文件，将其扩展名更改为 .bat。你可以将其命名为upload_to_ftp.bat或其他你喜欢的名字。首先，你需要创建一个新的文本文件，将其扩展名更改为 .ps1。它将自动执行一系列FTP命令，将本地文件夹的内容上传到FTP服务器的指定文件夹中。
FTP文件传输服务器
最新发布
想做职场小白吗? 我来教您.......
08-28 1912
（1）配置了虚拟用户登录后，本地用户登录就会失效。可以通过修改PAM认证文件调用的模块函数库可以解决。（2）vsftpd主配置文件中必须要开启本地登录模式。如果不开，将报错，提示本地模式和匿名模式必须开启一个，显然虚拟用户模式就是为了提高安全，因此我们不开匿名模式而开启本地模式。（3）2.6.4节中的主配置文件参数allow_writeable_chroot=YES必须开启如果不开将报错。（4）防火墙影响ftp登录，默认情况防火墙策略阻止了ftp端口，ftp客户端登录将得到“无法路由到主机”的报错。
Intellij IDEA 配置ftp自动上传代码到服务器
这货有些呆
05-04 946
Intellij IDEA 配置ftp自动上传代码到服务器，实现实时更新
FTPClient 远程文件读写(Java)
热门推荐
丫丫狸笫的专栏
03-18 1万+
apache.common.net.ftp,不是用sun.net.ftp /* 写文件apkInfoFileName: 若文件不存在，则新建文件apkInfoFileName，写入内容versionCode+path; 若文件存在，则向文件中追加内容"\n"+versionCode+path; */ OutputStreamWriter out = new Ou
ftpget服务器指定目录文件到指定目录下
05-13
要使用FTP从服务器下载文件并将其放置在指定目录下，可以使用以下命令： ```bash ftp -p <server_address> ``` 这将连接到FTP服务器并启动FTP客户端。接下来，您需要使用用户名和密码进行身份验证： ```bash Name (ftp.example.com:user): your_username Password: your_password ``` 一旦您成功登录，您可以使用以下命令浏览服务器上的文件： ```bash ftp> ls ``` 要下载文件，请使用以下命令： ```bash ftp> get /path/to/remote_file /path/to/local_directory ``` 这将从服务器的指定路径中获取文件，并将其放置在本地指定目录下。 请注意，这仅适用于您有足够权限访问服务器上的文件的情况。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值