ftp上传_ftp上传文件 - CSDN
精华内容
参与话题
  • 使用FTP上传文件 利用FTP和云服务器进行文件传输首先需要 云服务器配置好FTP环境后,您可以通过: 1.资源管理器 2.第三方软件 与服务器进行文件传输 与服务器进行文件传输时首先要确保服务器安全组开放了21端口...

    使用FTP上传文件

    利用FTP和云服务器进行文件传输首先需要 云服务器配置好FTP环境后,您可以通过:

    1.资源管理器

    2.第三方软件

    与服务器进行文件传输

    与服务器进行文件传输时首先要确保服务器安全组开放了21端口(入站规则为TCP21号)

     

    1.通过资源管理器进行文件传输

    打开电脑自带的资源管理器。 在上方输入ftp://主机IP

    输入用户名和密码验证通过后即可完成连接

    如果连接过程中弹出错误窗口时 通过“开始”-“控制面板”打开控制面板

    找到“网络和Internet”并点击

    点击Internet选项

    在弹出的窗口中找到高级并点击,在设置的勾选框中取消勾选“使用被动FTP”,点击“应用”后“确定”

    之后再重新试一下即可连接成功

     

    2.使用第三方软件进行文件传输

    这里以CuteFTP 9.0为例进行示范 首先去下载CuteFTP,下载安装完成后,打开软件,通过“文件”-“新建”-“FTP站点”,在弹出的窗口进行一些设置: (1)在“一般”输入相应的信息,登录方法为“普通” (2)在“类型”选择数据连接类型为“使用PORT”,端口为21(如果不小心关闭了也可在“站点管理器”找到要更改的云服务器右键-“属性”重新打开)

    点击连接即可连接成功,左侧为本地文件,右侧为服务器文件,鼠标拖动(或右键-上载/下载)即可完成上载和下载

     

    3.我的热门文章推荐

    4.我的视频类文章推荐

     
    展开全文
  • FTP文件上传与下载

    千次阅读 多人点赞 2012-07-13 11:27:33
    实现FTP文件上传与下载可以通过以下两种种方式实现(不知道还有没有其他方式,),分别为:1、通过JDK自带的API实现;2、通过Apache提供的API是实现。 第一种方式 package com.cloudpower.util; import java.io....

    实现FTP文件上传与下载可以通过以下两种种方式实现(不知道还有没有其他方式,大笑),分别为:1、通过JDK自带的API实现;2、通过Apache提供的API是实现。

    第一种方式

    package com.cloudpower.util;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    import sun.net.TelnetInputStream;
    import sun.net.TelnetOutputStream;
    import sun.net.ftp.FtpClient;
    
    /**
     * Java自带的API对FTP的操作
     * @Title:Ftp.java
     * @author: 周玲斌  
     */
    public class Ftp {
        /**
         * 本地文件名
         */
        private String localfilename;
        /**
         * 远程文件名
         */
        private String remotefilename;
        /**
         * FTP客户端
         */
        private FtpClient ftpClient;
    
        /**
         * 服务器连接
         * @param ip 服务器IP
         * @param port 服务器端口
         * @param user 用户名
         * @param password 密码
         * @param path 服务器路径
         * @author 周玲斌
         * @date   2012-7-11
         */
        public void connectServer(String ip, int port, String user,
                String password, String path) {
            try {
                /* ******连接服务器的两种方法*******/
                //第一种方法
    //            ftpClient = new FtpClient();
    //            ftpClient.openServer(ip, port);
                //第二种方法
                ftpClient = new FtpClient(ip);
                
                ftpClient.login(user, password);
                // 设置成2进制传输
                ftpClient.binary();
                System.out.println("login success!");
                if (path.length() != 0){
                    //把远程系统上的目录切换到参数path所指定的目录
                    ftpClient.cd(path);
                }
                ftpClient.binary();
            } catch (IOException ex) {
                ex.printStackTrace();
                throw new RuntimeException(ex);
            }
        }
        /**
         * 关闭连接
         * @author 周玲斌
         * @date   2012-7-11
         */
        public void closeConnect() {
            try {
                ftpClient.closeServer();
                System.out.println("disconnect success");
            } catch (IOException ex) {
                System.out.println("not disconnect");
                ex.printStackTrace();
                throw new RuntimeException(ex);
            }
        }
        /**
         * 上传文件
         * @param localFile 本地文件
         * @param remoteFile 远程文件
         * @author 周玲斌
         * @date   2012-7-11
         */
        public void upload(String localFile, String remoteFile) {
            this.localfilename = localFile;
            this.remotefilename = remoteFile;
            TelnetOutputStream os = null;
            FileInputStream is = null;
            try {
                //将远程文件加入输出流中
                os = ftpClient.put(this.remotefilename);
                //获取本地文件的输入流
                File file_in = new File(this.localfilename);
                is = new FileInputStream(file_in);
                //创建一个缓冲区
                byte[] bytes = new byte[1024];
                int c;
                while ((c = is.read(bytes)) != -1) {
                    os.write(bytes, 0, c);
                }
                System.out.println("upload success");
            } catch (IOException ex) {
                System.out.println("not upload");
                ex.printStackTrace();
                throw new RuntimeException(ex);
            } finally{
                try {
                    if(is != null){
                        is.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    try {
                        if(os != null){
                            os.close();
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        
        /**
         * 下载文件
         * @param remoteFile 远程文件路径(服务器端)
         * @param localFile 本地文件路径(客户端)
         * @author 周玲斌
         * @date   2012-7-11
         */
        public void download(String remoteFile, String localFile) {
            TelnetInputStream is = null;
            FileOutputStream os = null;
            try {
                //获取远程机器上的文件filename,借助TelnetInputStream把该文件传送到本地。
                is = ftpClient.get(remoteFile);
                File file_in = new File(localFile);
                os = new FileOutputStream(file_in);
                byte[] bytes = new byte[1024];
                int c;
                while ((c = is.read(bytes)) != -1) {
                    os.write(bytes, 0, c);
                }
                System.out.println("download success");
            } catch (IOException ex) {
                System.out.println("not download");
                ex.printStackTrace();
                throw new RuntimeException(ex);
            } finally{
                try {
                    if(is != null){
                        is.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    try {
                        if(os != null){
                            os.close();
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    
        public static void main(String agrs[]) {
    
            String filepath[] = { "/temp/aa.txt", "/temp/regist.log"};
            String localfilepath[] = { "C:\\tmp\\1.txt","C:\\tmp\\2.log"};
    
            Ftp fu = new Ftp();
            /*
             * 使用默认的端口号、用户名、密码以及根目录连接FTP服务器
             */
            fu.connectServer("127.0.0.1", 22, "anonymous", "IEUser@", "/temp");
            
            //下载
            for (int i = 0; i < filepath.length; i++) {
                fu.download(filepath[i], localfilepath[i]);
            }
            
            String localfile = "E:\\号码.txt";
            String remotefile = "/temp/哈哈.txt";
            //上传
            fu.upload(localfile, remotefile);
            fu.closeConnect();
        }
    }
    这种方式没啥可说的,比较简单,也不存在中文乱码的问题。貌似有个缺陷,不能操作大文件,有兴趣的朋友可以试试。

    第二种方式

    public class FtpApche {
        private static FTPClient ftpClient = new FTPClient();
        private static String encoding = System.getProperty("file.encoding");
        /**
         * Description: 向FTP服务器上传文件
         * 
         * @Version1.0
         * @param url
         *            FTP服务器hostname
         * @param port
         *            FTP服务器端口
         * @param username
         *            FTP登录账号
         * @param password
         *            FTP登录密码
         * @param path
         *            FTP服务器保存目录,如果是根目录则为“/”
         * @param filename
         *            上传到FTP服务器上的文件名
         * @param input
         *            本地文件输入流
         * @return 成功返回true,否则返回false
         */
        public static boolean uploadFile(String url, int port, String username,
                String password, String path, String filename, InputStream input) {
            boolean result = false;
    
            try {
                int reply;
                // 如果采用默认端口,可以使用ftp.connect(url)的方式直接连接FTP服务器
                ftpClient.connect(url);
                // ftp.connect(url, port);// 连接FTP服务器
                // 登录
                ftpClient.login(username, password);
                ftpClient.setControlEncoding(encoding);
                // 检验是否连接成功
                reply = ftpClient.getReplyCode();
                if (!FTPReply.isPositiveCompletion(reply)) {
                    System.out.println("连接失败");
                    ftpClient.disconnect();
                    return result;
                }
    
                // 转移工作目录至指定目录下
                boolean change = ftpClient.changeWorkingDirectory(path);
                ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
                if (change) {
                    result = ftpClient.storeFile(new String(filename.getBytes(encoding),"iso-8859-1"), input);
                    if (result) {
                        System.out.println("上传成功!");
                    }
                }
                input.close();
                ftpClient.logout();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (ftpClient.isConnected()) {
                    try {
                        ftpClient.disconnect();
                    } catch (IOException ioe) {
                    }
                }
            }
            return result;
        }
    
        /**
         * 将本地文件上传到FTP服务器上
         * 
         */
        public void testUpLoadFromDisk() {
            try {
                FileInputStream in = new FileInputStream(new File("E:/号码.txt"));
                boolean flag = uploadFile("127.0.0.1", 21, "zlb","123", "/", "哈哈.txt", in);
                System.out.println(flag);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }
    
    
        /**
         * Description: 从FTP服务器下载文件
         * 
         * @Version1.0
         * @param url
         *            FTP服务器hostname
         * @param port
         *            FTP服务器端口
         * @param username
         *            FTP登录账号
         * @param password
         *            FTP登录密码
         * @param remotePath
         *            FTP服务器上的相对路径
         * @param fileName
         *            要下载的文件名
         * @param localPath
         *            下载后保存到本地的路径
         * @return
         */
        public static boolean downFile(String url, int port, String username,
                String password, String remotePath, String fileName,
                String localPath) {
            boolean result = false;
            try {
                int reply;
                ftpClient.setControlEncoding(encoding);
                
                /*
                 *  为了上传和下载中文文件,有些地方建议使用以下两句代替
                 *  new String(remotePath.getBytes(encoding),"iso-8859-1")转码。
                 *  经过测试,通不过。
                 */
    //            FTPClientConfig conf = new FTPClientConfig(FTPClientConfig.SYST_NT);
    //            conf.setServerLanguageCode("zh");
    
                ftpClient.connect(url, port);
                // 如果采用默认端口,可以使用ftp.connect(url)的方式直接连接FTP服务器
                ftpClient.login(username, password);// 登录
                // 设置文件传输类型为二进制
                ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
                // 获取ftp登录应答代码
                reply = ftpClient.getReplyCode();
                // 验证是否登陆成功
                if (!FTPReply.isPositiveCompletion(reply)) {
                    ftpClient.disconnect();
                    System.err.println("FTP server refused connection.");
                    return result;
                }
                // 转移到FTP服务器目录至指定的目录下
                ftpClient.changeWorkingDirectory(new String(remotePath.getBytes(encoding),"iso-8859-1"));
                // 获取文件列表
                FTPFile[] fs = ftpClient.listFiles();
                for (FTPFile ff : fs) {
                    if (ff.getName().equals(fileName)) {
                        File localFile = new File(localPath + "/" + ff.getName());
                        OutputStream is = new FileOutputStream(localFile);
                        ftpClient.retrieveFile(ff.getName(), is);
                        is.close();
                    }
                }
    
                ftpClient.logout();
                result = true;
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (ftpClient.isConnected()) {
                    try {
                        ftpClient.disconnect();
                    } catch (IOException ioe) {
                    }
                }
            }
            return result;
        }
    
        /**
         * 将FTP服务器上文件下载到本地
         * 
         */
        public void testDownFile() {
            try {
                boolean flag = downFile("127.0.0.1", 21, "zlb",
                        "123", "/", "哈哈.txt", "D:/");
                System.out.println(flag);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        
        public static void main(String[] args) {
            FtpApche fa = new FtpApche();
            fa.testDownFile();
        }
    }
    
    这种方式的话需要注意中文乱码问题啦,如果你设置不恰当,有可能上传的文件名会为乱码,有的时候根本就上传不上去,当然,也不会跟你提示,因为原本就没异常。在网上找了好多解答方案,众说纷纭,几乎都是从一个版本拷贝过去的,也没有经过自己的真是检验。为此,也吃了不少苦头。大致分为以下两种解决方案:

    1、加上以下三句即可解决

    ftpClient.setControlEncoding(“GBK”);

    FTPClientConfig conf = new FTPClientConfig(FTPClientConfig.SYST_NT);
    conf.setServerLanguageCode("zh");
    解答:经过测试,根本上行不通,上述问题依然存在

    2、与上述方式有所类似,但我觉得这种方式更靠谱一点

    首先,加上ftpClient.setControlEncoding(“GBK”);这一句,然后,将所有的中文进行转码为“ISO-8859-1”格式,如下:

    ftpClient.changeWorkingDirectory(new String(remotePath.getBytes("GBK"),"iso-8859-1"));

    解答:经过测试,仍然行不通,之所以我说此方式更靠谱一点,请继续往下看

    首先我们来说说为什么要进行转码:

    因为在FTP协议里面,规定文件名编码为iso-8859-1,所以目录名或文件名需要转码。

    接下来的问题是,我们应该将什么编码转换为此格式。因此,就有了第二种解决方案——把GBK格式的转换为ISO-8859-1格式。而且,有的人还说,必须得这么转。其实,之所以他们能这么说,我觉得完全是巧合。它的真正原理是,既然FTP协议规定的编码格式是“ISO-8859-1”,那么我们确实得将格式转换一下,然后等服务器收到文件时再自动转换为系统自带的编码格式,因此,关键不是规定为什么格式,而是取决于FTP服务器的编码格式。因此,如果FTP系统的编码格式为“GBK”时,第二种方式肯定会成功;但是,如果系统的编码格式为“UTF-8”时,那就会仍然出现乱码啦。所以,我们只能通过代码先获取系统的编码格式,然后通过此编码格式转换为ISO-8859-1的编码格式。获取方式如下:

    private static String encoding = System.getProperty("file.encoding");

    以上代码均通过自己测试,望能为大家解决一下问题!顺便提供一下FTP服务器搭建工具Serv-U,里面包含了注册机,需要的请点击下载。如果注册时有什么问题请及时回复!

    展开全文
  • ftp上传文件至服务器

    千次阅读 2018-03-12 17:01:27
    上传action public void putTxtToFTP() { System.out.println("开始执行定时器任务:维系一键体检订单量!"); Calendar calendar = Calendar.getInstance(); calendar.add(Calendar.DATE, -1); //...

    上传action

    public void putTxtToFTP() {
            System.out.println("开始执行定时器任务:维系一键体检订单量!");
            Calendar calendar = Calendar.getInstance();
            calendar.add(Calendar.DATE, -1); //得到前一天
            Date date = calendar.getTime();
            SimpleDateFormat df = new SimpleDateFormat("yyyyMMdd");
            String yesterday = df.format(date);
    
            StringBuffer yjtjOrderTxt = new StringBuffer();
            yjtjOrderTxt.append("yjtywx_").append(yesterday).append(".txt");
    
    
            List<WxActiveData> yjtjOrderList = activeDataService.wxGetYjtjOrder();
    
            //FtpUtil ftpUtil = new FtpUtil("hexin","hx105155","134.64.105.155", "/yjtydd");  //测试库FTP
            FtpUtil ftpUtil = new FtpUtil("ahftp","ahdx@#$_123dic","192.168.0.28", "/yjtydd");     
            PrintWriter printWriter = null;
            File highFeeFile = new File(Contants.FILE_PATH_BAK + yjtjOrderTxt);//Contants.FILE_PATH_BAK = "/opt/wss/domains/tmp/"
    
    //      File highFeeFile = new File("D:/" + highFeeTxt);
    //      File gjmyFile = new File("D:/" + gjmyTxt);
            //File highFeeFile = new File("D:/" + yjtjOrderTxt);
            try {
                printWriter = new PrintWriter(new FileWriter(highFeeFile, true));
                for (int i = 0; i < yjtjOrderList.size(); i++){
                    printWriter.println(yjtjOrderList.get(i).toString().trim());
                }
            } catch (IOException e) {
                System.out.println("主动服务 高额数据报表任务异常!");
            }finally{
                printWriter.close();
            }
            if(highFeeFile.exists()){
                System.out.println("主动服务定时器任务 高额数据 上传成功"+yjtjOrderTxt.toString());
                ftpUtil.uploadFile(highFeeFile, yjtjOrderTxt.toString());
            }else{
                System.out.println("主动服务定时器任务 高额数据 上传失败"+yjtjOrderTxt.toString());
            }
    
            System.out.println("维系一键体检订单报表结束");
    
        }
    
        public ActiveDataService getActiveDataService() {
            return activeDataService;
        }
    
        public void setActiveDataService(ActiveDataService activeDataService) {
            this.activeDataService = activeDataService;
        }

    上传工具类

    /**
     * FTP工具类
     * 
     * @author 李顺
     * 
     */
    public class FtpUtil {
    
        private String host;
    
        private String userName;
    
        private String password;
    
        private int port = 21;
    
        private String pathname;
    
        private FTPClient ftpClient;
    
        private String fileName;
    
        public FtpUtil() {
    
        }
    
        public FtpUtil(String userName, String password, String host,
                String pathname) {
            this.userName = userName;
            this.password = password;
            this.host = host;
            this.pathname = pathname;
        }
    
        public void uploadFile(File file, String fileName) {
            System.out.println("**************开始ftp上传******************");
            System.out.println("ftp服务器IP:" + host);
            System.out.println("ftp服务器userName:" + userName);
            System.out.println("ftp服务器password:" + password);
            System.out.println("ftp服务器pathname:" + pathname);
            System.out.println("*******************************************");
    
            ftpClient = new FTPClient();
            FileInputStream fis = null;
    
            try {
                // 输入流
                fis = new FileInputStream(file);
                System.out.println("===获取本地文件流====");
                // 连接服务器
                ftpClient.connect(host);
                System.out.println("====建立远程连接====");
                ftpClient.enterLocalPassiveMode();
    
                // 登录FTP
                ftpClient.login(userName, password);
                System.out.println("====登录FTP====");
                // 指定写入的目录
                ftpClient.changeWorkingDirectory(pathname);
                System.out.println("====指定写入的目录====");
    
                ftpClient.setBufferSize(1024*1024);
    
                ftpClient.setControlEncoding("GBK");
    
                // 写操作
                ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
    
                ftpClient.storeFile(fileName, fis);
                System.out.println("====写入文件====");
            } catch (Exception e) {
                System.out.println("上传异常====" + e.getMessage());
                e.printStackTrace();
                throw new RuntimeException("FTP客户端出错!", e);
            } finally {
    
                try {
                    fis.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
    
                if (ftpClient.isConnected()) {
                    try {
                        ftpClient.disconnect();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }
    
        /**
         * 上传集团文件
         * @param file
         * @param fileName
         */
        public Map uploadJTFile(File file, String fileName) {
            Map<String, String> m = new HashMap<String, String>();
            String flag = "0";
            System.out.println("**************开始ftp上传******************");
            System.out.println("ftp服务器IP:" + host);
            System.out.println("ftp服务器userName:" + userName);
            System.out.println("ftp服务器password:" + password);
            System.out.println("ftp服务器pathname:" + pathname);
            System.out.println("*******************************************");
    
            ftpClient = new FTPClient();
            FileInputStream fis = null;
    
            try {
                // 输入流
                fis = new FileInputStream(file);
                System.out.println("===获取本地文件流====");
                // 连接服务器
                ftpClient.connect(host,22);//集团的连接22端口
                System.out.println("====建立远程连接====");
                ftpClient.enterLocalPassiveMode();
    
                // 登录FTP
                ftpClient.login(userName, password);
                System.out.println("====登录FTP====");
                // 指定写入的目录
                ftpClient.changeWorkingDirectory(pathname);
                System.out.println("====指定写入的目录====");
    
                ftpClient.setBufferSize(1024*1024);
    
                ftpClient.setControlEncoding("UTF-8");
    
                // 写操作
                ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
    
                ftpClient.storeFile(fileName, fis);
                System.out.println("====写入文件====");
                m.put("flag", flag);
                m.put("msg", "");
            } catch (Exception e) {
                flag = "-1";
                System.out.println("上传异常====" + e.getMessage());
                m.put("flag", flag);
                m.put("msg", e.getMessage());
            } finally {
                try {
                    fis.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
                if (ftpClient.isConnected()) {
                    try {
                        ftpClient.disconnect();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return m;
        }
    
    
        /**
         * 端到端定时任务专用
         */
        public int downloadFileForClient(String remoteFileName, String localPath) {
            ftpClient = new FTPClient();
            int flag = -1;//成功
            try {
                // 连接服务器
                ftpClient.connect(host);
                ftpClient.enterLocalPassiveMode();
                // 登录FTP
                ftpClient.login(userName, password);
                // 指定写入的目录
                ftpClient.changeWorkingDirectory(pathname);
                ftpClient.setBufferSize(1024);
                ftpClient.setControlEncoding("UTF-8");
                // 写操作
                ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
                FTPFile[] files = ftpClient.listFiles();
                if (files == null) {
                    System.out.println("====远程FTP文件列表为空=====");
                }
                for (int i = 0; i < files.length; i++) {
    
                    if (files[i] == null || files[i].getName() == null) {
                        System.out.println("====文件为空=====");
                        continue;
                    }
                    String name = files[i].getName();
                    if(remoteFileName.equals(name)){
                        System.out.println("下载" + name + ".......");
                        File file = new File(localPath + name);
                        FileOutputStream fos = new FileOutputStream(file);
                        ftpClient.retrieveFile(name, fos);
                        flag = 0;
                        try {
                            fos.close();
                        } catch (IOException e1) {
                            e1.printStackTrace();
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
                throw new RuntimeException("FTP客户端出错!", e);
            } finally {
    
                if (ftpClient.isConnected()) {
                    try {
                        ftpClient.disconnect();
                        return flag;
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return flag;
        }
        /**
         * ppm定时任务专用
         */
        public void downloadFile(String systemPath, String localPath) {
            ftpClient = new FTPClient();
    
            try {
    
                // 连接服务器
                ftpClient.connect(host);
    
                ftpClient.enterLocalPassiveMode();
    
                // 登录FTP
                ftpClient.login(userName, password);
    
                // 指定写入的目录
                ftpClient.changeWorkingDirectory(pathname);
    
                ftpClient.setBufferSize(1024);
    
                ftpClient.setControlEncoding("UTF-8");
    
                // 写操作
                ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
    
                FTPFile[] files = ftpClient.listFiles(systemPath);
                if (files == null) {
                    System.out.println("====远程FTP文件列表为空=====");
                } else {
                    System.out.println("====远程FTP文件列表长度=====" + files.length);
                }
                for (int i = 0; i < files.length; i++) {
    
                    if (files[i] == null || files[i].getName() == null) {
                        System.out.println("====文件为空=====");
                        continue;
                    }
                    String name = files[i].getName();
                    if (name.indexOf("PRODUCT_") > -1
                            && (name.toUpperCase().endsWith(".TXT"))
                            && (name.indexOf("_" + DateUtil.twoDayBefore()) > -1)) {
                        System.out.println("下载" + name + ".......");
                        File file = new File(localPath + name);
                        FileOutputStream fos = new FileOutputStream(file);
                        ftpClient.retrieveFile(systemPath + name, fos);
                        try {
                            fos.close();
                        } catch (IOException e1) {
                            e1.printStackTrace();
                        }
                    }
                    if (name.indexOf("PROD_OFFER_") > -1
                            && (name.toUpperCase().endsWith(".TXT"))
                            && (name.indexOf("_" + DateUtil.twoDayBefore()) > -1)) {
                        System.out.println("下载" + name + ".......");
                        File file = new File(localPath + name);
                        FileOutputStream fos = new FileOutputStream(file);
                        ftpClient.retrieveFile(systemPath + name, fos);
                        try {
                            fos.close();
                        } catch (IOException e1) {
                            e1.printStackTrace();
                        }
                    }
                    if (name.indexOf("OFFER_PROD_REL_") > -1
                            && (name.toUpperCase().endsWith(".TXT"))
                            && (name.indexOf("_" + DateUtil.twoDayBefore()) > -1)) {
                        System.out.println("下载" + name + ".......");
                        File file = new File(localPath + name);
                        FileOutputStream fos = new FileOutputStream(file);
                        ftpClient.retrieveFile(systemPath + name, fos);
                        try {
                            fos.close();
                        } catch (IOException e1) {
                            e1.printStackTrace();
                        }
                    }
                    if (name.indexOf("PRICING_DESC_TYPE_") > -1
                            && (name.toUpperCase().endsWith(".TXT"))
                            && (name.indexOf("_" + DateUtil.twoDayBefore()) > -1)) {
                        System.out.println("下载" + name + ".......");
                        File file = new File(localPath + name);
                        FileOutputStream fos = new FileOutputStream(file);
                        ftpClient.retrieveFile(systemPath + name, fos);
                        try {
                            fos.close();
                        } catch (IOException e1) {
                            e1.printStackTrace();
                        }
                    }
                    if (name.indexOf("TB_PTY_CODE_") > -1
                            && (name.toUpperCase().endsWith(".TXT"))
                            && (name.indexOf("_" + DateUtil.twoDayBefore()) > -1)) {
                        System.out.println("下载" + name + ".......");
                        File file = new File(localPath + name);
                        FileOutputStream fos = new FileOutputStream(file);
                        ftpClient.retrieveFile(systemPath + name, fos);
                        try {
                            fos.close();
                        } catch (IOException e1) {
                            e1.printStackTrace();
                        }
                    }
                    if (name.indexOf("OFFER_GROUP_PRICING_DESC_") > -1
                            && (name.toUpperCase().endsWith(".TXT"))
                            && (name.indexOf("_" + DateUtil.twoDayBefore()) > -1)) {
                        System.out.println("下载" + name + ".......");
                        File file = new File(localPath + name);
                        FileOutputStream fos = new FileOutputStream(file);
                        ftpClient.retrieveFile(systemPath + name, fos);
                        try {
                            fos.close();
                        } catch (IOException e1) {
                            e1.printStackTrace();
                        }
                    } 
                    if(name.indexOf("_fail.txt") > -1 && (name.toUpperCase().endsWith(".TXT"))){
                        System.out.println("下载" + name + ".......");
                        File file = new File(localPath + name);
                        FileOutputStream fos = new FileOutputStream(file);
                        ftpClient.retrieveFile(systemPath + name, fos);
                        try {
                            fos.close();
                        } catch (IOException e1) {
                            e1.printStackTrace();
                        }
                    }
                    if(name.indexOf("_success") > -1 && (name.toUpperCase().endsWith(".TXT"))){
                        System.out.println("下载" + name + ".......");
                        System.out.println("new File :"+localPath + name);
                        System.out.println("new File2 :"+systemPath + name);
    
                        File file = new File(localPath + name);
                        FileOutputStream fos = new FileOutputStream(file);
                        ftpClient.retrieveFile(systemPath + name, fos);
                        try {
                            fos.close();
                        } catch (IOException e1) {
                            e1.printStackTrace();
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
                throw new RuntimeException("FTP客户端出错!", e);
            } finally {
    
                if (ftpClient.isConnected()) {
                    try {
                        ftpClient.disconnect();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }
    
        public String getHost() {
            return host;
        }
    
        public void setHost(String host) {
            this.host = host;
        }
    
        public String getUserName() {
            return userName;
        }
    
        public void setUserName(String userName) {
            this.userName = userName;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        public int getPort() {
            return port;
        }
    
        public void setPort(int port) {
            this.port = port;
        }
    
        public String getPathname() {
            return pathname;
        }
    
        public void setPathname(String pathname) {
            this.pathname = pathname;
        }
    
        public FTPClient getFtpClient() {
            return ftpClient;
        }
    
        public void setFtpClient(FTPClient ftpClient) {
            this.ftpClient = ftpClient;
        }
    
        public String getFileName() {
            return fileName;
        }
    
        public void setFileName(String fileName) {
            this.fileName = fileName;
        }
    }
    展开全文
  • cmd命令进行ftp上传和下载

    万次阅读 2020-08-12 16:28:16
    1、登录ftp服务器ftp 192.168.147.1292、进入到待上传文件的本地目录命令:ftp&gt;lcd c:\Users\1\Desktop 输入命令:ftp&gt;!dir 可以查看本地目录中的文件和文件夹输入命令:ftp&gt;pwd 检查ftp当前...

    ===============================others=================================

    推荐一款ftp客户端工具:iis7服务器管理工具

        IIs7服务器管理工具可以批量管理ftp站点,除此之外,作为ftp客户端,它还具备定时上传,定时下载、定时备份,自动更新等功能。作为服务器集成管理器,它最优秀的功能就是批量管理windows与linux系统服务器、vps。能极大的提高站长及服务器运维人员工作效率。同时iis7服务器管理工具还是vnc客户端,服务器真正实现了一站式管理,可谓是非常方便。

    下载地址:http://fwqglgj.iis7.net?ccxc

    使用截图如下:

          

    ================================Content=================================

    1、登录ftp服务器

    ftp 192.168.147.129

     

    2、进入到待上传文件的本地目录

    命令:ftp>lcd c:\Users\1\Desktop  

    输入命令:ftp>!dir 可以查看本地目录中的文件和文件夹

     

    输入命令:ftp>pwd 检查ftp当前目录

     

    3、上传文件

    单文件上传:ftp>put name.txt

    多文件上传:ftp>mput *.txt (上传目录下所有.txt文件),多文件上传需要将交互模式设置为关,使用命令:ftp>prompt

     

    4、文件下载

    单文件下载:ftp>get name.txt

    多文件下载:ftp>mget *.txt(下载所有txt文件),ftp>mget * (下载所有文件)

     

    参考博客地址:https://www.cnblogs.com/adolphyang/p/5280255.html

     

     

    展开全文
  • ftp上传,下载两种方法

    千次阅读 2018-08-28 09:27:15
    实现FTP文件上传与下载可以通过以下两种种方式实现(不知道还有没有其他方式),分别为:1、通过JDK自带的API实现;2、通过Apache提供的API是实现。 第一种方式 package com.cloudpower.util; import java.io....
  • 将图片上传FTP服务器

    千次阅读 热门讨论 2020-06-04 15:36:49
    FTP服务器】 FTP是什么? FTP是File Transfer Protocol(文件传输协议)的英文简称,用于Internet上的控制文件的双向...在FTP的使用当中,用户经常遇到两个概念,下载和上传,下载就是从远程主机拷贝文件至自己的计
  • FTP是一种文件传输协议,它支持两种模式,一种方式叫做Standard (也就是 Active,主动方式),一种是 Passive (也就是PASV,被动方式)。 Standard模式 FTP的客户端发送 PORT 命令到FTP server。Passive模式FTP的客户端...
  • FTP服务器(File Transfer Protocol Server)是在互联网上提供文件存储和访问服务的计算机,它们依照FTP协议提供服务。 FTP是File Transfer Protocol(文件传输协议)。顾名思义,就是专门用来传输文件的协议。简单地...
  • FTP上传下载命令

    2020-07-27 23:30:32
    FTP上传下载命令,实现在shell或者crt上进行客户端与服务器之间的文件或者文件夹的上传下载
  • ftp命令上传文件

    万次阅读 2018-01-16 16:03:32
    ftp上传文件 ftp -s:ftp1.bat open 192.168.4.104 anonymous anonymous lcd AppData\Roaming\MicroSIP cd SIP binary get Contacts.xml get MicroSIP.ini Close quit 来
  • 问题:在上传过程中,出现“打开ftp服务器上的文件夹时发生错误,请检查是否有权限访问该文件夹"错误。 解决方法:打开控制面板-》网络和Internet 点击 Internet选项 Internet属性&gt;&gt;高级&...
  • linux ftp 上传文件命令

    万次阅读 2017-08-18 17:58:22
    首先我们需要先进入到ftp环境 $ ftp ip地址 账号/密码 然后进入到对应的目录 ftp>!ls 查看一下文件列表 我们首先需要使用lcd命令设定本地接受目录位置。 我们首先需要使用lcd命令设定本地接收目录位置 lcd /...
  • 如何将文件上传ftp

    万次阅读 2018-07-10 16:54:58
    方法1(推荐,炒鸡简单): 双击我的电脑,在地址栏里输入你的ftp地址回车(比如: ftp...+ 具体步骤如下: 1、通过windows控制面板的程序和功能,进入启用和关闭windows功能,组件中添加FTP功能 2、选择下一步,...
  • 解决FTP上传文件速度慢的问题

    万次阅读 2018-06-15 13:57:48
    我们在利用ftp的storeFile()上传存储文件的时候,为了让上传速度提升,建议采用添加缓冲区的方式,根据上传文件的大 小,设置缓冲区大小,上传的过程中,缓冲区写满后才会进行磁盘的读写操作。ftp.setBufferSize...
  • 工程在现场进行项目实施,提到FTP上传文件失败; 反馈回来后,测试没有问题,但是现场一直有问题。 在开发环境下测试都是正常的,既然软件没有问题,那么肯定是现场的工程环境存在问题; 通过获取GetLastError,...
  • mac Finder FTP 不可以上传和编辑文件

    万次阅读 2014-10-31 12:10:02
    finder链接FTP后,不能将文件直接拖动到FTP目录。 匿名用户和有密码的都一样。 只能下载,不可以上传和编辑。 解决办法,安装 ftp 客户端软件。
  • Java实现ftp上传文件、文件夹

    万次阅读 热门讨论 2012-04-06 09:49:42
    import java.io.File; import java.io.FileInputStream; import org.apache.commons.net.ftp.FTPClient; import org.apache.commons.net.ftp.FTPReply; public class test {
  • 上传ftp 服务器,中文出现乱码解决:  我遇到的 ftp 服务是设置编码为:GB2312 。注意要在 connect 之前就设置编码。  ftpClient.setControlEncoding("GB2312"); /** * 参数获取FTPClient对象 * @param...
  • ftp.upecho ftp&gt;&gt;ftp.upecho ""&gt;&gt; ftp.upecho cd pub &gt;&gt; ftp.upEcho binary&gt;&gt;ftp.upEcho put D:\softinfo.xml &gt;&gt; ftp.upEcho bye...
  • 可以利用下面的脚本将文件夹从本地服务器FTP上传到远程服务器: #!/bin/bash  #upload dir to remote ftp server read -p "Input local dir: " updir #local dir read -p "Input remote dir: " todir #remote dir ...
1 2 3 4 5 ... 20
收藏数 122,584
精华内容 49,033
关键字:

ftp上传